diff --git a/MindEyeV2/src/TestUnclip.ipynb b/MindEyeV2/src/TestUnclip.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f58e6a61c22082f7e1752dd1dfacf84a21ce889e --- /dev/null +++ b/MindEyeV2/src/TestUnclip.ipynb @@ -0,0 +1,693 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7eb3889c-6baf-4e4e-94cd-fe80406d6b7b", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "99375f3b-7008-411a-97d1-56cbbe6ae273", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: cuda\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder, FrozenOpenCLIPEmbedder2\n", + "from generative_models.sgm.models.diffusion import DiffusionEngine\n", + "from generative_models.sgm.util import append_dims\n", + "from omegaconf import OmegaConf\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "from models import *\n", + "\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "device = accelerator.device\n", + "print(\"device:\",device)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "43afb31f-30a3-4a53-81e2-5cdc3adc209b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_40sess_24bs\n", + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"final_subj01_pretrained_40sess_24bs\"\n", + " print(\"model_name:\", model_name)\n", + "\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --model_name={model_name} --subj=1 \\\n", + " --hidden_dim=4096 --n_blocks=4 --new_test\"\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6b4fac96-2051-439e-961a-2817f5e511b7", + "metadata": {}, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"will load ckpt for model found in ../train_logs/model_name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Validate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_blocks\",type=int,default=4,\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=2048,\n", + ")\n", + "parser.add_argument(\n", + " \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)\n", + "\n", + "# make output directory\n", + "os.makedirs(\"evals\",exist_ok=True)\n", + "os.makedirs(f\"evals/{model_name}\",exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9c3d689d-b9a2-4211-86ec-f8453844993d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/weka/proj-medarc/shared/mindeyev2_dataset'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache_dir" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "264993c6-47d3-481e-a81b-0e8a82a8341f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3bd6f6639b1f4af99edaeb8b59f6fbe9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "open_clip_pytorch_model.bin: 0%| | 0.00/10.2G [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the first 64 images (512,3,600,600)\n", + "fig, axs = plt.subplots(8, 8, figsize=(16, 16))\n", + "for i, ax in enumerate(axs.flat):\n", + " ax.imshow(stimuli_images[i].permute(1,2,0))\n", + " ax.axis('off')\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6c684bc8-bee1-4570-ac63-b91df3e4d459", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([512, 3, 600, 600])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cue_images_path = '/weka/proj-medarc/shared/umn-neuroimaging/imageryrf_single_trial/stimuli/cue_images.pt'\n", + "cue_images = torch.load(cue_images_path)\n", + "cue_images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "419871e3-c8d6-4d1a-92a2-4279360c34da", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the first 64 images (512,3,600,600)\n", + "fig, axs = plt.subplots(8, 8, figsize=(16, 16))\n", + "for i, ax in enumerate(axs.flat):\n", + " ax.imshow(cue_images[i].permute(1,2,0))\n", + " ax.axis('off')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "fa4c92de-d108-4064-b4dd-9a79197f5c4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([512, 3, 600, 600])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "object_images_path = '/weka/proj-medarc/shared/umn-neuroimaging/imageryrf_single_trial/stimuli/object_images.pt'\n", + "object_images = torch.load(object_images_path)\n", + "object_images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0e6696c8-c786-42b9-b280-f8d6ff25d689", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the first 64 images (512,3,600,600)\n", + "fig, axs = plt.subplots(8, 8, figsize=(16, 16))\n", + "for i, ax in enumerate(axs.flat):\n", + " ax.imshow(object_images[i].permute(1,2,0))\n", + " ax.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "285bd7cd-6bac-40f9-85b6-59a138eb9e6a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 64/64 [00:01<00:00, 44.23it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "torch.Size([64, 256, 1664])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch_size = 1\n", + "# pass the first 64 images through the clip_img_embedder\n", + "for i in tqdm(range(64)):\n", + " img = stimuli_images[i].unsqueeze(0).to(device)\n", + " encoded = clip_img_embedder.encode_with_vision_transformer(img)[1]\n", + " if i==0:\n", + " clip_encoded = encoded\n", + " else:\n", + " clip_encoded = torch.cat([clip_encoded, encoded], dim=0)\n", + "clip_encoded.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "f857600e-2edd-43cb-9fa2-17b66c841c17", + "metadata": {}, + "outputs": [], + "source": [ + "batch={\"jpg\": torch.randn(1,3,1,1).to(device), # jpg doesnt get used, it's just a placeholder\n", + " \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n", + " \"crop_coords_top_left\": torch.zeros(1, 2).to(device)}\n", + "out = diffusion_engine.conditioner(batch)\n", + "vector_suffix = out[\"vector\"].to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "cf6c97ff-9c61-4a44-abdd-8c8ae5ea6ba5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/64 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the results of the first 64 images\n", + "fig, axs = plt.subplots(8, 8, figsize=(16, 16))\n", + "for i, ax in enumerate(axs.flat):\n", + " ax.imshow(recon_samples[i].squeeze().detach().cpu().numpy().transpose(1,2,0))\n", + " ax.axis('off')\n", + "\n", + "# save the image with full quality\n", + "plt.savefig(f\"evals/{model_name}/recon_samples.png\", dpi=300, bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c33fef8a-d868-4289-96fa-da7678965c65", + "metadata": {}, + "outputs": [], + "source": [ + "# save the results\n", + "torch.save(recon_samples, f\"evals/{model_name}/recon_samples.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "6a0c1a4e-d16b-45d4-bb45-1101024014f2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 64/64 [00:01<00:00, 41.45it/s]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 64/64 [05:38<00:00, 5.29s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Same with object images\n", + "batch_size = 1\n", + "# pass the first 64 images through the clip_img_embedder\n", + "for i in tqdm(range(64)):\n", + " img = object_images[i].unsqueeze(0).to(device)\n", + " encoded = clip_img_embedder.encode_with_vision_transformer(img)[1]\n", + " if i==0:\n", + " clip_encoded = encoded\n", + " else:\n", + " clip_encoded = torch.cat([clip_encoded, encoded], dim=0)\n", + "clip_encoded.shape\n", + "\n", + "# reconstruct the first 64 images\n", + "for i in tqdm(range(64)):\n", + " clip_embed = clip_encoded[i].unsqueeze(0)\n", + " samples = utils.unclip_recon(clip_embed,\n", + " diffusion_engine,\n", + " vector_suffix,\n", + " num_samples=1)\n", + " \n", + " if i==0:\n", + " recon_samples = samples\n", + " else:\n", + " recon_samples = torch.cat([recon_samples, samples], dim=0)\n", + "recon_samples.shape\n", + "\n", + "# plot the results of the first 64 images\n", + "fig, axs = plt.subplots(8, 8, figsize=(16, 16))\n", + "for i, ax in enumerate(axs.flat):\n", + " ax.imshow(recon_samples[i].squeeze().detach().cpu().numpy().transpose(1,2,0))\n", + " ax.axis('off')\n", + "\n", + "# save the image with full quality\n", + "plt.savefig(f\"evals/{model_name}/recon_samples_object.png\", dpi=300, bbox_inches='tight')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/TrainB5k.py b/MindEyeV2/src/TrainB5k.py new file mode 100644 index 0000000000000000000000000000000000000000..fe80df77e775c196f68a0c0330bd1f32e37263fa --- /dev/null +++ b/MindEyeV2/src/TrainB5k.py @@ -0,0 +1,1438 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Import packages & functions + +# In[1]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm +import webdataset as wds + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from accelerate import Accelerator + +# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main +sys.path.append('generative_models/') +import sgm +from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[2]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +data_type = torch.float16 # change depending on your mixed_precision +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# First use "accelerate config" in terminal and setup using deepspeed stage 2 with CPU offloading! +accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job + global_batch_size = batch_size = 16 + +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + + +# In[3]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +num_devices = torch.cuda.device_count() +if num_devices==0 or not distributed: num_devices = 1 +num_workers = num_devices +print(accelerator.state) + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[4]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + model_name = "testing" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the 2nd cell block + jupyter_args = f"--data_path=/weka/proj-medarc/shared/bold5000/nsd_general \ + --cache_dir=/weka/proj-medarc/shared/cache \ + --model_name={model_name} \ + --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=15 \ + --hidden_dim=1024 --clip_scale=1. \ + --no-blurry_recon --blur_scale=.5 \ + --use_prior --prior_scale=30 \ + --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \ + --ckpt_interval=999 --no-ckpt_saving --no-wandb_log" + # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow + + print(jupyter_args) + jupyter_args = jupyter_args.split() + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[5]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default=os.getcwd(), + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--cache_dir", type=str, default=os.getcwd(), + help="Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8], + help="Validate on which subject?", +) +parser.add_argument( + "--multisubject_ckpt", type=str, default=None, + help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.", +) +parser.add_argument( + "--num_sessions", type=int, default=1, + help="Number of training sessions to include", +) +parser.add_argument( + "--use_prior",action=argparse.BooleanOptionalAction,default=True, + help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)", +) +parser.add_argument( + "--batch_size", type=int, default=16, + help="Batch size can be increased by 10x if only training retreival submodule and not diffusion prior", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=.5, + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--prior_scale",type=float,default=30, + help="multiply diffusion prior loss by this", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=False, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=150, + help="number of epochs of training", +) +parser.add_argument( + "--multi_subject",action=argparse.BooleanOptionalAction,default=False, +) +parser.add_argument( + "--new_test",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--n_blocks",type=int,default=4, +) +parser.add_argument( + "--hidden_dim",type=int,default=1024, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +# seed all random functions +utils.seed_everything(seed) + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) + +if use_image_aug or blurry_recon: + import kornia + from kornia.augmentation.container import AugmentationSequential +if use_image_aug: + img_augment = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + +if multi_subject: + subj_list = np.arange(1,9) + subj_list = subj_list[subj_list != subj] +else: + subj_list = [subj] + +print("subj_list", subj_list, "num_sessions", num_sessions) + + +# # Prep data, models, and dataloaders + +# ### Creating wds dataloader, preload betas and all 73k possible images + +# In[6]: + + +def my_split_by_node(urls): return urls +num_voxels_list = [] + +if multi_subject: + nsessions_allsubj=np.array([15, 15, 15, 9]) + num_samples_per_epoch = (370*15) // num_devices +else: + num_samples_per_epoch = (370*num_sessions) // num_devices + +print("dividing batch size by subj_list, which will then be concatenated across subj during training...") +batch_size = batch_size // len(subj_list) +samples_per_session = 370 + + +# In[9]: + + +from torch.utils.data import DataLoader, Dataset +from torch.utils.data.distributed import DistributedSampler +from sklearn.model_selection import train_test_split + +class BoldDataset(Dataset): + def __init__(self, voxels, images, sessions_mask, indexes): + self.voxels = voxels + self.images = images + self.sessions_mask = sessions_mask + self.indexes = indexes + self.num_samples = len(voxels) + def __len__(self): + return self.num_samples + def __getitem__(self, idx): + return self.voxels[idx], self.images[idx], self.sessions_mask[idx], self.indexes[idx] + +def get_voxels_and_images(subj, num_sessions, data_path, mode, random_state = 42): + """ + subj: int, subject number + num_sessions: int, number of sessions to include, can be -1 for all + data_path: str, path to the data + mode: str, mode can be 'train', 'val', 'shared' and 'all' and "t&v" + random_state: int, random state for train_test_split + """ + + # load the voxels + all_voxels = torch.load(os.path.join(data_path, f"subj{subj}/wholebrain.pt")) + # all_voxels = torch.load(os.path.join(data_path, f"subj{subj}/voxels.pt")) + all_voxels = torch.where(torch.isnan(all_voxels), torch.zeros_like(all_voxels), all_voxels) + # load the other files + all_images = torch.load(os.path.join(data_path, f"subj{subj}/images_stimuli.pt")) + shared_images_mask = torch.load(os.path.join(data_path, f"subj{subj}/shared_images_mask.pt")) + sessions_mask = torch.load(os.path.join(data_path, f"subj{subj}/sessions_mask.pt")) + indexes = np.linspace(0, all_voxels.shape[0],num=all_voxels.shape[0], dtype=int) + # split the data into train and val with sklearn train_test_split + voxels_train, voxels_val, images_train, images_val, shared_images_mask_train, shared_images_mask_val, sessions_mask_train, sessions_mask_val, indexes_train, indexes_val = train_test_split(all_voxels, all_images, shared_images_mask, sessions_mask, indexes, test_size=0.1, random_state=random_state) + + if mode == 'train': + # apply the shared images mask removing the ones in which is 1 + voxels_train = voxels_train[shared_images_mask_train==0] + images_train = images_train[shared_images_mask_train==0] + sessions_mask_train = sessions_mask_train[shared_images_mask_train==0] + indexes_train = indexes_train[shared_images_mask_train==0] + + # apply the sessions mask, the mask has values from 1 to 15, if num_sessions is 4, we will take the elements in which the value is 1 to 4 + if num_sessions != -1: + voxels_train = voxels_train[sessions_mask_train <= num_sessions] + images_train = images_train[sessions_mask_train <= num_sessions] + indexes_train = indexes_train[sessions_mask_train <= num_sessions] + sessions_mask_train = sessions_mask_train[sessions_mask_train <= num_sessions] + + return voxels_train, images_train, sessions_mask_train, indexes_train + + elif mode == 'val': + # apply the shared images mask removing the ones in which is 1 + voxels_val = voxels_val[shared_images_mask_val==0] + images_val = images_val[shared_images_mask_val==0] + sessions_mask_val = sessions_mask_val[shared_images_mask_val==0] + indexes_val = indexes_val[shared_images_mask_val==0] + + return voxels_val, images_val, sessions_mask_val, indexes_val + + elif mode == 'shared': + # apply the shared images mask taking only the ones in which is 1 + voxels_shared = all_voxels[shared_images_mask==1] + images_shared = all_images[shared_images_mask==1] + indexes_shared = indexes[shared_images_mask==1] + sessions_mask_shared = sessions_mask[shared_images_mask==1] + + return voxels_shared, images_shared, sessions_mask_shared, indexes_shared + + elif mode == 't&v': + voxels_tv = all_voxels[shared_images_mask==0] + images_tv = all_images[shared_images_mask==0] + indexes_tv = indexes[shared_images_mask==0] + sessions_mask_tv = sessions_mask[shared_images_mask==0] + + return voxels_tv, images_tv, sessions_mask_tv, indexes_tv + + elif mode == 'all': + return all_voxels, all_images, sessions_mask, indexes + +# voxels, images, sessions_idx, sample_idx = get_voxels_and_images(subj, num_sessions, data_path, 'train') +# print("voxels.shape", voxels.shape, "images.shape", images.shape, "sessions_idx.shape", sessions_idx.shape, "sample_idx.shape", sample_idx.shape) + + +# In[11]: + + +train_data = {} +train_dl = {} +num_voxels = {} +voxels = {} +for s in subj_list: + # TODO: Check num_sessions is working, replace -1 + voxels_train, images_train, sessions_idx_train, sample_idx_train = get_voxels_and_images(s, -1, data_path, 'train') + train_data[f'subj0{s}'] = BoldDataset(voxels_train, images_train, sessions_idx_train, sample_idx_train) + train_dl[f'subj0{s}'] = DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True, drop_last=True) + print(f"Training with {num_sessions} sessions") + num_voxels[f'subj0{s}'] = voxels_train.shape[-1] + num_voxels_list.append(num_voxels[f'subj0{s}']) + # TODO: Delete this part if it's not needed and delete the variable declaration above as well + voxels[f'subj0{s}'] = voxels_train + +print("Loaded all subj train dls and betas!\n") + + # if multi_subject: + # train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{nsessions_allsubj[s-1]-1}" + "}.tar" + # else: + # train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{num_sessions-1}" + "}.tar" + # print(train_url) + + # train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\ + # .shuffle(750, initial=1500, rng=random.Random(42))\ + # .decode("torch")\ + # .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + # .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) + # train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + + # f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r') + # betas = f['betas'][:] + # betas = torch.Tensor(betas).to("cpu").to(data_type) + # num_voxels_list.append(betas[0].shape[-1]) + # num_voxels[f'subj0{s}'] = betas[0].shape[-1] + # voxels[f'subj0{s}'] = betas + # print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}") + +print("Loaded all subj train dls and betas!\n") + +# Validate only on one subject +if multi_subject: + subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list +# if not new_test: # using old test set from before full dataset released (used in original MindEye paper) +# if subj==3: +# num_test=2113 +# elif subj==4: +# num_test=1985 +# elif subj==6: +# num_test=2113 +# elif subj==8: +# num_test=1985 +# else: +# num_test=2770 +# test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +# elif new_test: # using larger test set from after full dataset released +# if subj==3: +# num_test=2371 +# elif subj==4: +# num_test=2188 +# elif subj==6: +# num_test=2371 +# elif subj==8: +# num_test=2188 +# else: +# num_test=3000 +# test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" +# print(test_url) + +voxels_test, images_test, sessions_idx_test, sample_idx_test = get_voxels_and_images(subj, num_sessions, data_path, 'val') +test_data = BoldDataset(voxels_test, images_test, sessions_idx_test, sample_idx_test) +test_dl = DataLoader(test_data, batch_size=voxels_test.shape[0], shuffle=False, num_workers=num_workers, pin_memory=True) +num_test = voxels_test.shape[0] +# test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ +# .shuffle(750, initial=1500, rng=random.Random(42))\ +# .decode("torch")\ +# .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ +# .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +# test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +print(f"Loaded test dl for subj{subj}!\n") + + +# In[13]: + + +num_samples_per_epoch = 0 +for dt_c in train_data: + num_samples_per_epoch = num_samples_per_epoch + train_data[dt_c].voxels.shape[0] +# num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list)) +num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list)) + +print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch) + + +# In[14]: + + +# # now plot inside the traning loop +# for batch in train_dl[f'subj0{subj}']: +# voxels, images, sessions_idx, sample_idx = batch +# print("voxels.shape", voxels.shape, "images.shape", images.shape, "sessions_idx.shape", sessions_idx.shape, "sample_idx.shape", sample_idx.shape) +# indexes_to_plot = [1,3,4,5,6] +# fig, axs = plt.subplots(1, len(indexes_to_plot), figsize=(20, 5)) +# for i, idx in enumerate(indexes_to_plot): +# axs[i].imshow(images[idx].permute(1, 2, 0)) +# axs[i].axis('off') +# plt.show() +# break + +# # now plot inside the traning loop +# for batch in test_dl: +# voxels, images, sessions_idx, sample_idx = batch +# print("voxels.shape", voxels.shape, "images.shape", images.shape, "sessions_idx.shape", sessions_idx.shape, "sample_idx.shape", sample_idx.shape) +# indexes_to_plot = [1,3,4,5,6] +# fig, axs = plt.subplots(1, len(indexes_to_plot), figsize=(20, 5)) +# for i, idx in enumerate(indexes_to_plot): +# axs[i].imshow(images[idx].permute(1, 2, 0)) +# axs[i].axis('off') +# plt.show() +# break + + +# In[15]: + + +# train_data = {} +# train_dl = {} +# num_voxels = {} +# voxels = {} +# for s in subj_list: +# print(f"Training with {num_sessions} sessions") +# if multi_subject: +# train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{nsessions_allsubj[s-1]-1}" + "}.tar" +# else: +# train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{num_sessions-1}" + "}.tar" +# print(train_url) + +# train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\ +# .shuffle(750, initial=1500, rng=random.Random(42))\ +# .decode("torch")\ +# .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ +# .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +# train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +# f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r') +# betas = f['betas'][:] +# betas = torch.Tensor(betas).to("cpu").to(data_type) +# num_voxels_list.append(betas[0].shape[-1]) +# num_voxels[f'subj0{s}'] = betas[0].shape[-1] +# voxels[f'subj0{s}'] = betas +# print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}") + +# print("Loaded all subj train dls and betas!\n") + +# # Validate only on one subject +# if multi_subject: +# subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list +# if not new_test: # using old test set from before full dataset released (used in original MindEye paper) +# if subj==3: +# num_test=2113 +# elif subj==4: +# num_test=1985 +# elif subj==6: +# num_test=2113 +# elif subj==8: +# num_test=1985 +# else: +# num_test=2770 +# test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +# elif new_test: # using larger test set from after full dataset released +# if subj==3: +# num_test=2371 +# elif subj==4: +# num_test=2188 +# elif subj==6: +# num_test=2371 +# elif subj==8: +# num_test=2188 +# else: +# num_test=3000 +# test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" +# print(test_url) +# test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ +# .shuffle(750, initial=1500, rng=random.Random(42))\ +# .decode("torch")\ +# .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ +# .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +# test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +# print(f"Loaded test dl for subj{subj}!\n") + + +# In[16]: + + +# # Load 73k NSD images +# f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +# images = f['images'] +# print("Loaded all 73k possible NSD images to cpu!", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[17]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) + +clip_seq_dim = 256 +clip_emb_dim = 1664 + + +# ### SD VAE + +# In[18]: + + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + from autoencoder.convnext import ConvnextXL + cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth') + cnx.requires_grad_(False) + cnx.eval() + cnx.to(device) + + mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1) + std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1) + + blur_augs = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8), + kornia.augmentation.RandomGrayscale(p=0.1), + kornia.augmentation.RandomSolarize(p=0.1), + kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0), + data_keys=["input"], + ) + + +# ### MindEye modules + +# In[19]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[20]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +# test on subject 1 with fake data +b = torch.randn((2,1,num_voxels_list[0])) +print(b.shape, model.ridge(b,0).shape) + + +# In[21]: + + +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, + blurry_recon=blurry_recon, clip_scale=clip_scale) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((2,1,hidden_dim)) +print("b.shape",b.shape) + +backbone_, clip_, blur_ = model.backbone(b) +print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape) + + +# ### Adding diffusion prior + unCLIP if use_prior=True + +# In[22]: + + +if use_prior: + from models import * + + # setup diffusion prior network + out_dim = clip_emb_dim + depth = 6 + dim_head = 52 + heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim + timesteps = 100 + + prior_network = PriorNetwork( + dim=out_dim, + depth=depth, + dim_head=dim_head, + heads=heads, + causal=False, + num_tokens = clip_seq_dim, + learned_query_mode="pos_emb" + ) + + model.diffusion_prior = BrainDiffusionPrior( + net=prior_network, + image_embed_dim=out_dim, + condition_on_text_encodings=False, + timesteps=timesteps, + cond_drop_prob=0.2, + image_embed_scale=None, + ) + + utils.count_params(model.diffusion_prior) + utils.count_params(model) + + +# ### Setup optimizer / lr / ckpt saving + +# In[23]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] + +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] +if use_prior: + opt_grouped_parameters.extend([ + {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} + ]) + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*num_iterations_per_epoch)) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + if accelerator.is_main_process: + unwrapped_model = accelerator.unwrap_model(model) + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + print(f"\n---saved {outdir}/{tag} ckpt!---\n") + +def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): + print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + if multisubj_loading: # remove incompatible ridge layer that will otherwise error + state_dict.pop('ridge.linears.0.weight',None) + model.load_state_dict(state_dict, strict=strict) + if load_epoch: + globals()["epoch"] = checkpoint['epoch'] + print("Epoch",epoch) + if load_optimizer: + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + if load_lr: + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + del checkpoint + +print("\nDone with model preparations!") +num_params = utils.count_params(model) + + +# # Weights and Biases + +# In[24]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeye' + print(f"wandb {wandb_project} run {model_name}") + # need to configure wandb beforehand in terminal with "wandb init"! + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "num_sessions": num_sessions, + "num_params": num_params, + "clip_scale": clip_scale, + "prior_scale": prior_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_samples_per_epoch": num_samples_per_epoch, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + # "train_url": train_url, + # "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + print("wandb_id:",model_name) + wandb.init( + id=model_name, + project=wandb_project, + name=model_name, + config=wandb_config, + resume="allow", + ) +else: + wandb_log = False + + +# # Main + +# In[25]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +torch.cuda.empty_cache() + + +# In[26]: + + +# load multisubject stage1 ckpt if set +if multisubject_ckpt is not None: + load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True) + + +# In[27]: + + +train_dls = [train_dl[f'subj0{s}'] for s in subj_list] + +model, optimizer, *train_dls, lr_scheduler = accelerator.prepare(model, optimizer, *train_dls, lr_scheduler) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[28]: + + +for voxels, images, sessions_mask, sample_idx in train_dls[0]: + print(voxels.shape, images.shape, sessions_mask.shape, sample_idx.shape) + break + + +# In[29]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + recon_cossim = 0. + test_recon_cossim = 0. + recon_mse = 0. + test_recon_mse = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_blurry_cont_total = 0. + test_loss_clip_total = 0. + + loss_prior_total = 0. + test_loss_prior_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch) + voxel_iters = {} # empty dict because diff subjects have differing # of voxels + image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float() + annot_iters = {} + perm_iters, betas_iters, select_iters = {}, {}, {} + for s, train_dl in enumerate(train_dls): + with torch.cuda.amp.autocast(dtype=data_type): + iter = -1 + for voxels, images, sessions_mask, sample_idx in train_dl: + # for behav0, past_behav0, future_behav0, old_behav0 in train_dl: + # Load images to cpu from hdf5 (requires sorted indexing) + # image_idx = behav0[:,0,0].cpu().long().numpy() + # image0, image_sorted_idx = np.unique(image_idx, return_index=True) + # if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing + # continue + iter += 1 + # image0 = torch.tensor(images[image0], dtype=data_type) + # image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0 + image_iters[iter,s*batch_size:s*batch_size+batch_size] = images + + # Load voxels for current batch, matching above indexing + # voxel_idx = behav0[:,0,5].cpu().long().numpy() + # voxel_sorted_idx = voxel_idx[image_sorted_idx] + # voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx] + # voxel0 = torch.Tensor(voxel0).unsqueeze(1) + # print(voxels.shape) + voxel0 = voxels.unsqueeze(1) + # print(voxel0.shape) + if epoch < int(mixup_pct * num_epochs): + voxel0, perm, betas, select = utils.mixco(voxel0) + # voxel0, perm, betas, select = utils.mixco(voxel0) + perm_iters[f"subj0{subj_list[s]}_iter{iter}"] = perm + betas_iters[f"subj0{subj_list[s]}_iter{iter}"] = betas + select_iters[f"subj0{subj_list[s]}_iter{iter}"] = select + + voxel_iters[f"subj0{subj_list[s]}_iter{iter}"] = voxel0 + # print(voxel0.shape) + + if iter >= num_iterations_per_epoch-1: + break + + # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each + for train_i in range(num_iterations_per_epoch): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + loss=0. + + voxel_list = [voxel_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + image = image_iters[train_i].detach() + image = image.to(device) + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_img_embedder(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + perm_list = [perm_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + perm = torch.cat(perm_list, dim=0) + betas_list = [betas_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + betas = torch.cat(betas_list, dim=0) + select_list = [select_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + select = torch.cat(select_list, dim=0) + + voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)] + voxel_ridge = torch.cat(voxel_ridge_list, dim=0) + + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if use_prior: + loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target) + loss_prior_total += loss_prior.item() + loss_prior *= prior_scale + loss += loss_prior + + recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item() + recon_mse += mse(prior_out, clip_target).item() + + if clip_scale>0: + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, transformer_feats = blurry_image_enc_ + + image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215 + loss_blurry = l1(image_enc_pred, image_enc) + loss_blurry_total += loss_blurry.item() + + if epoch < int(mixup_pct * num_epochs): + image_enc_shuf = image_enc[perm] + betas_shape = [-1] + [1]*(len(image_enc.shape)-1) + image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \ + image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape) + + image_norm = (image - mean)/std + image_aug = (blur_augs(image) - mean)/std + _, cnx_embeds = cnx(image_norm) + _, cnx_aug_embeds = cnx(image_aug) + + cont_loss = utils.soft_cont_loss( + nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1), + nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + temp=0.2) + loss_blurry_cont_total += cont_loss.item() + + loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215 + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + # print(utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item(), utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()) + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + blurry_pixcorr += pixcorr.item() + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + # for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + for test_i, (voxels, images, sessions_mask, sample_idx) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + # assert len(behav) == num_test + + ## Average same-image repeats ## + # if test_image is None: + # # voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1) + # voxel = voxels.unsqueeze(1) + # # image = behav[:,0,0].cpu().long() + # image = images + + # unique_image, sort_indices = torch.unique(image, return_inverse=True) + # for im in unique_image: + # locs = torch.where(im == image)[0] + # if len(locs)==1: + # locs = locs.repeat(3) + # elif len(locs)==2: + # locs = locs.repeat(2)[:3] + # assert len(locs)==3 + # if test_image is None: + # test_image = torch.Tensor(images[im][None]) + # test_voxel = voxel[locs][None] + # else: + # test_image = torch.vstack((test_image, torch.Tensor(images[im][None]))) + # test_voxel = torch.vstack((test_voxel, voxel[locs][None])) + test_image = images + test_voxel = voxels.unsqueeze(1) + + loss=0. + + # test_indices = torch.arange(len(test_voxel))[:] + # voxel = test_voxel[test_indices].to(device) + # image = test_image[test_indices].to(device) + # assert len(image) == 100 + image = test_image.to(device) + voxel = test_voxel.to(device) + + clip_target = clip_img_embedder(image.float()) + + # REPETITION AVERAGING INFERENCE DOESN'T APPLY SINCE WE'RE USING VALIDATION SET + # for rep in range(3): + # voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list + # backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge) + # if rep==0: + # clip_voxels = clip_voxels0 + # backbone = backbone0 + # else: + # clip_voxels += clip_voxels0 + # backbone += backbone0 + # clip_voxels /= 3 + # backbone /= 3 + + voxel_ridge = model.ridge(voxel,0) # 0th index of subj_list + + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # for some evals, only doing a subset of the samples per batch because of computational cost + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + + if use_prior: + loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps]) + test_loss_prior_total += loss_prior.item() + loss_prior *= prior_scale + loss += loss_prior + + if clip_scale>0: + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, _ = blurry_image_enc_ + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + test_blurry_pixcorr += pixcorr.item() + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/recon_cossim": recon_cossim / (train_i + 1), + "test/recon_cossim": test_recon_cossim / (test_i + 1), + "train/recon_mse": recon_mse / (train_i + 1), + "test/recon_mse": test_recon_mse / (test_i + 1), + "train/loss_prior": loss_prior_total / (train_i + 1), + "test/loss_prior": test_loss_prior_total / (test_i + 1), + } + + # if finished training, save jpg recons if they exist + if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0): + if blurry_recon: + image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215 + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/blur_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + if wandb_log: wandb.log(logs) + + # Save model checkpoint and reconstruct + if (ckpt_saving) and (epoch % ckpt_interval == 0): + save_ckpt(f'last') + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') + + +# In[ ]: + + +# voxel_iters.keys() + + +# In[ ]: + + +# # create a new dl +# test_voxels, test_images, test_sessions_idx, test_sample_idx = get_voxels_and_images(subj, num_sessions, data_path, 'shared') +# test_data = BoldDataset(test_voxels, test_images, test_sessions_idx, test_sample_idx) +# test_dl = DataLoader(test_data, batch_size=test_voxels.shape[0], shuffle=False, num_workers=num_workers, pin_memory=True) + + +# In[ ]: + + +aaa + + +# In[ ]: + + +# # find the unique images in the test set +# unique_images = torch.unique(test_images, dim=0) +# print("unique_images.shape", unique_images.shape) + + +# In[ ]: + + +v1_images = torch.load('/weka/proj-medarc/shared/bold5000/v1/subj1/images_stimuli.pt') +wb_images = torch.load('/weka/proj-medarc/shared/bold5000/formated/subj1/images_stimuli.pt') + + +# In[ ]: + + +wb_images.device + + +# In[ ]: + + +# wb_images = torch.load('/weka/proj-medarc/shared/bold5000/formated/subj1/images_stimuli.pt') # (5254, 3, 224, 224) + +# iterate one in train_dl +for b1_voxels, b1_images, b1_sessions_idx, b1_sample_idx in test_dl: + print(b1_voxels.shape, b1_images.shape, b1_sessions_idx.shape, b1_sample_idx.shape) + break + +b1_sample = b1_images[1].to('cpu') # (3, 224, 224) +# check the index of the first image b1_images[1] in wb_images + +mask = (wb_images == b1_sample.unsqueeze(0)) +# Reduce over the last three dimensions one by one: +mask = mask.all(dim=3).all(dim=2).all(dim=1) + +indices = torch.where(mask)[0] +if len(indices) > 0: + print("Found b1_images[1] at index(es):", indices.tolist()) +else: + print("No exact match found.") + + +# In[ ]: + + +v1_images[4095,0,0,10:100], b1_images[1,0,0,10:100], wb_voxels[4095,1000:1020], b1_voxels[1,1000:1020] + + +# In[ ]: + + +b1_voxels.min() + + +# In[ ]: + + +wb_images.shape + + +# In[ ]: + + +v1_voxels = torch.load(f'/weka/proj-medarc/shared/bold5000/v1/subj1/voxels.pt') +wb_voxels = torch.load(f'/weka/proj-medarc/shared/bold5000/formated/subj1/wholebrain.pt') + + +# In[ ]: + + +v1_voxels.max(), v1_voxels.min(), wb_voxels.max(), wb_voxels.min() + + +# In[ ]: + + +# for i in train_dl + + +# In[ ]: + + +from tqdm import tqdm +import torch + +# Extract the first example from each tensor +v1_example = v1_voxels[0] # shape: [1685] +wb_example = wb_voxels[0] # shape: [174019] + +# Round both sets of voxels to 4 decimal places +v1_rounded = torch.round(v1_example * 1000) / 1000 +wb_rounded = torch.round(wb_example * 1000) / 1000 + +# Convert wb_rounded to a set for O(1) membership checks +wb_set = set(wb_rounded.tolist()) + +count = 0 +# Iterate over each voxel in v1_rounded and check if it exists in wb_rounded +for voxel in tqdm(v1_rounded, desc="Checking V1 voxels"): + if voxel.item() in wb_set: + count += 1 + +print(f"Number of V1 voxels present in the WB example (up to 4 decimals): {count}") + + +# In[ ]: + + + + + +# In[ ]: + + +# Extract the first example from each tensor +v1_example = v1_voxels[0] # shape: [1685] +wb_example = wb_voxels[0] # shape: [174019] + +# Convert wb_example to a set for O(1) membership checks +wb_set = set(wb_example.tolist()) + +count = 0 +# Iterate over each voxel in v1_example and check if it exists in wb_example +for voxel in tqdm(v1_example, desc="Checking V1 voxels"): + value = voxel.item() + if count == 0: + value = 1.0938 + + if value in wb_set: + count += 1 + +print(f"Number of V1 voxels present in the WB example: {count}") + + +# In[ ]: + + +v1_voxels = torch.load(f'/weka/proj-medarc/shared/bold5000/v1/subj1/voxels.pt') +wb_voxels = torch.load(f'/weka/proj-medarc/shared/bold5000/formated/subj1/wholebrain.pt') + + +# In[ ]: + + +v1_voxels.shape, wb_voxels[0,1006:1060] + + +# In[ ]: + + +v1_voxels.shape, wb_voxels[0,1006:1060] + + +# In[ ]: + + +# # plot train images +indexes_to_plot = [1,3,4,5,6] +fig, axs = plt.subplots(1, len(indexes_to_plot), figsize=(20, 5)) +for i, idx in enumerate(indexes_to_plot): + axs[i].imshow(v1_images[idx].permute(1, 2, 0)) + axs[i].axis('off') +plt.show() + + +# In[ ]: + + +# # plot train images +indexes_to_plot = [1,3,4,5,6] +fig, axs = plt.subplots(1, len(indexes_to_plot), figsize=(20, 5)) +for i, idx in enumerate(indexes_to_plot): + axs[i].imshow(wb_images[idx].permute(1, 2, 0)) + axs[i].axis('off') +plt.show() + + +# In[ ]: + + +# train_i + + +# In[ ]: + + +# fwd_percent_correct/ + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/MindEyeV2/src/TrainBold5000-Copy1.ipynb b/MindEyeV2/src/TrainBold5000-Copy1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7b5aa06bd0d5b9307ba3ba1f38d8bbb95e613933 --- /dev/null +++ b/MindEyeV2/src/TrainBold5000-Copy1.ipynb @@ -0,0 +1,1669 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "data_type = torch.float16 # change depending on your mixed_precision\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "# First use \"accelerate config\" in terminal and setup using deepspeed stage 2 with CPU offloading!\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job\n", + " global_batch_size = batch_size = 8\n", + "else:\n", + " global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + " batch_size = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 2098275\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: fp16\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0 or not distributed: num_devices = 1\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: testingbold5000\n", + "--data_path=/weka/proj-medarc/shared/bold5000/v1 --cache_dir=/weka/proj-medarc/shared/cache --model_name=testingbold5000 --no-multi_subject --subj=1 --batch_size=8 --num_sessions=14 --hidden_dim=1024 --clip_scale=1. --no-blurry_recon --blur_scale=.5 --use_prior --prior_scale=30 --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug --ckpt_interval=999 --no-ckpt_saving --wandb_log\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"testingbold5000\"\n", + " print(\"model_name:\", model_name)\n", + " \n", + " # global_batch_size and batch_size should already be defined in the 2nd cell block\n", + " jupyter_args = f\"--data_path=/weka/proj-medarc/shared/bold5000/v1 \\\n", + " --cache_dir=/weka/proj-medarc/shared/cache \\\n", + " --model_name={model_name} \\\n", + " --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=14 \\\n", + " --hidden_dim=1024 --clip_scale=1. \\\n", + " --no-blurry_recon --blur_scale=.5 \\\n", + " --use_prior --prior_scale=30 \\\n", + " --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \\\n", + " --ckpt_interval=999 --no-ckpt_saving --wandb_log\"\n", + " # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow\n", + "\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj_list [1] num_sessions 14\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Validate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multisubject_ckpt\", type=str, default=None,\n", + " help=\"Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_sessions\", type=int, default=1,\n", + " help=\"Number of training sessions to include\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_prior\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=16,\n", + " help=\"Batch size can be increased by 10x if only training retreival submodule and not diffusion prior\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=.5,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--prior_scale\",type=float,default=30,\n", + " help=\"multiply diffusion prior loss by this\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=150,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multi_subject\",action=argparse.BooleanOptionalAction,default=False,\n", + ")\n", + "parser.add_argument(\n", + " \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_blocks\",type=int,default=4,\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=1024,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)\n", + "\n", + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + " \n", + "if use_image_aug or blurry_recon:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + "if use_image_aug:\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )\n", + " \n", + "if multi_subject:\n", + " subj_list = np.arange(1,9)\n", + " subj_list = subj_list[subj_list != subj]\n", + "else:\n", + " subj_list = [subj]\n", + "\n", + "print(\"subj_list\", subj_list, \"num_sessions\", num_sessions)" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "### Creating wds dataloader, preload betas and all 73k possible images" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "aefe7c27-ab39-4b2c-90f4-480f4087b7ab", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dividing batch size by subj_list, which will then be concatenated across subj during training...\n", + "batch_size = 8 num_iterations_per_epoch = 656 num_samples_per_epoch = 5254\n" + ] + } + ], + "source": [ + "def my_split_by_node(urls): return urls\n", + "num_voxels_list = []\n", + "\n", + "n_trials_per_subject = [5254, 5254, 5254, 3108] \n", + "\n", + "if multi_subject:\n", + " nsessions_allsubj=np.array([15,15,15,9])\n", + " num_samples_per_epoch = (750*40) // num_devices \n", + "else:\n", + " num_samples_per_epoch = n_trials_per_subject[subj_list[0]] // num_devices \n", + "\n", + "print(\"dividing batch size by subj_list, which will then be concatenated across subj during training...\") \n", + "batch_size = batch_size // len(subj_list)\n", + "\n", + "num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))\n", + "\n", + "print(\"batch_size =\", batch_size, \"num_iterations_per_epoch =\",num_iterations_per_epoch, \"num_samples_per_epoch =\",num_samples_per_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8e8a3cc6-0627-4b61-b826-a6d2df93f122", + "metadata": {}, + "outputs": [], + "source": [ + "# load the data\n", + "images1 = torch.load('/weka/proj-medarc/shared/bold5000/v1/subj1/images_stimuli.pt')\n", + "voxelsv1 = torch.load('/weka/proj-medarc/shared/bold5000/v1/subj1/voxels.pt')\n", + "\n", + "voxels1 = torch.load('/weka/proj-medarc/shared/bold5000/formated/subj1/wholebrain.pt')\n", + "sessions_mask = torch.load(os.path.join('/weka/proj-medarc/shared/bold5000/formated/', f\"subj{subj}/sessions_mask.pt\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9f412984-30f6-46d5-9d00-f8277aa0e30c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([5254, 174019]) torch.Size([5254])\n" + ] + } + ], + "source": [ + "print(voxels1.shape, sessions_mask.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "74070791-7980-49aa-a8d3-0c238432c62f", + "metadata": {}, + "outputs": [], + "source": [ + "unique_sessions = sessions_mask.unique()\n", + "\n", + "# Prepare a container for the output (copy first, or you can create a new one)\n", + "voxels1_zscore = torch.empty_like(voxels1)\n", + "\n", + "# Loop over sessions\n", + "for sess in unique_sessions:\n", + " # Create a boolean mask for trials belonging to the current session\n", + " sess_mask = (sessions_mask == sess)\n", + "\n", + " # Extract the trials corresponding to this session\n", + " sess_data = voxels1[sess_mask, :] # shape: [num_session_trials, num_voxels]\n", + "\n", + " # Compute mean and std along trials (dim=0 is trials, dim=1 is voxels)\n", + " mean_sess = sess_data.mean(dim=0) # shape: [num_voxels]\n", + " std_sess = sess_data.std(dim=0) # shape: [num_voxels]\n", + "\n", + " # Avoid division by zero: if std is zero, set it to 1 (or handle as desired)\n", + " std_sess[std_sess == 0] = 1.0\n", + "\n", + " # Z-score the session data\n", + " sess_data_zscore = (sess_data - mean_sess) / std_sess\n", + "\n", + " # Place the z-scored data back into the output tensor\n", + " voxels1_zscore[sess_mask, :] = sess_data_zscore" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8a402d18-641f-45b4-aecd-cf6c7ec38447", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Summary for voxelsv1 ---\n", + "Min: -10.2188\n", + "Max: 8.6066\n", + "Mean: -0.0000\n", + "Std: 1.0000\n", + "Number of Outliers (|value - mean| > 3*std): 30371\n", + "--- Summary for voxels1 ---\n", + "Min: -5801.5703\n", + "Max: 4001.2046\n", + "Mean: 0.0192\n", + "Std: 1.7900\n", + "Number of Outliers (|value - mean| > 3*std): 8926010\n", + "--- Summary for voxels1_zscore ---\n", + "Min: -14.8227\n", + "Max: 11.8500\n", + "Mean: 0.0000\n", + "Std: 0.9876\n", + "Number of Outliers (|value - mean| > 3*std): 3272907\n" + ] + } + ], + "source": [ + "\n", + "def print_summary(tensor, name=\"Tensor\"):\n", + " # Convert tensor to CPU if needed, and flatten for convenience\n", + " data = tensor.detach().cpu().numpy().flatten() if torch.is_tensor(tensor) else tensor\n", + "\n", + " # Compute basic statistics\n", + " t_min = data.min()\n", + " t_max = data.max()\n", + " t_mean = data.mean()\n", + " t_std = data.std()\n", + "\n", + " # Simple outlier detection using a threshold, e.g., values beyond mean ± 3*std\n", + " lower_bound = t_mean - 3 * t_std\n", + " upper_bound = t_mean + 3 * t_std\n", + " outliers = data[(data < lower_bound) | (data > upper_bound)]\n", + "\n", + " # Print the summary\n", + " print(f\"--- Summary for {name} ---\")\n", + " print(f\"Min: {t_min:.4f}\")\n", + " print(f\"Max: {t_max:.4f}\")\n", + " print(f\"Mean: {t_mean:.4f}\")\n", + " print(f\"Std: {t_std:.4f}\")\n", + " print(f\"Number of Outliers (|value - mean| > 3*std): {len(outliers)}\")\n", + "\n", + "# Example usage:\n", + "print_summary(voxelsv1, \"voxelsv1\")\n", + "print_summary(voxels1, \"voxels1\")\n", + "print_summary(voxels1_zscore, \"voxels1_zscore\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7eaebdf4-22b7-4c9a-9572-9e69870735df", + "metadata": {}, + "outputs": [], + "source": [ + "voxels1 = voxels1_zscore" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'train_data = {}\\ntrain_dl = {}\\nnum_voxels = {}\\nvoxels = {}\\nfor s in subj_list:\\n print(f\"Training with {num_sessions} sessions\")\\n if multi_subject:\\n train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{nsessions_allsubj[s-1]-1}\" + \"}.tar\"\\n else:\\n train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{num_sessions-1}\" + \"}.tar\"\\n print(train_url)\\n \\n train_data[f\\'subj0{s}\\'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node) .shuffle(750, initial=1500, rng=random.Random(42)) .decode(\"torch\") .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\") .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\\n train_dl[f\\'subj0{s}\\'] = torch.utils.data.DataLoader(train_data[f\\'subj0{s}\\'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\\n\\n f = h5py.File(f\\'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5\\', \\'r\\')\\n betas = f[\\'betas\\'][:]\\n betas = torch.Tensor(betas).to(\"cpu\").to(data_type)\\n num_voxels_list.append(betas[0].shape[-1])\\n num_voxels[f\\'subj0{s}\\'] = betas[0].shape[-1]\\n voxels[f\\'subj0{s}\\'] = betas\\n print(f\"num_voxels for subj0{s}: {num_voxels[f\\'subj0{s}\\']}\")\\n\\nprint(\"Loaded all subj train dls and betas!\\n\")\\n\\n# Validate only on one subject\\nif multi_subject: \\n subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list\\nif not new_test: # using old test set from before full dataset released (used in original MindEye paper)\\n if subj==3:\\n num_test=2113\\n elif subj==4:\\n num_test=1985\\n elif subj==6:\\n num_test=2113\\n elif subj==8:\\n num_test=1985\\n else:\\n num_test=2770\\n test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\\nelif new_test: # using larger test set from after full dataset released\\n if subj==3:\\n num_test=2371\\n elif subj==4:\\n num_test=2188\\n elif subj==6:\\n num_test=2371\\n elif subj==8:\\n num_test=2188\\n else:\\n num_test=3000\\n test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\\nprint(test_url)\\ntest_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node) .shuffle(750, initial=1500, rng=random.Random(42)) .decode(\"torch\") .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\") .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\\ntest_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\\nprint(f\"Loaded test dl for subj{subj}!\\n\")'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"train_data = {}\n", + "train_dl = {}\n", + "num_voxels = {}\n", + "voxels = {}\n", + "for s in subj_list:\n", + " print(f\"Training with {num_sessions} sessions\")\n", + " if multi_subject:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{nsessions_allsubj[s-1]-1}\" + \"}.tar\"\n", + " else:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{num_sessions-1}\" + \"}.tar\"\n", + " print(train_url)\n", + " \n", + " train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + " train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + " f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r')\n", + " betas = f['betas'][:]\n", + " betas = torch.Tensor(betas).to(\"cpu\").to(data_type)\n", + " num_voxels_list.append(betas[0].shape[-1])\n", + " num_voxels[f'subj0{s}'] = betas[0].shape[-1]\n", + " voxels[f'subj0{s}'] = betas\n", + " print(f\"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}\")\n", + "\n", + "print(\"Loaded all subj train dls and betas!\\n\")\n", + "\n", + "# Validate only on one subject\n", + "if multi_subject: \n", + " subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list\n", + "if not new_test: # using old test set from before full dataset released (used in original MindEye paper)\n", + " if subj==3:\n", + " num_test=2113\n", + " elif subj==4:\n", + " num_test=1985\n", + " elif subj==6:\n", + " num_test=2113\n", + " elif subj==8:\n", + " num_test=1985\n", + " else:\n", + " num_test=2770\n", + " test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "elif new_test: # using larger test set from after full dataset released\n", + " if subj==3:\n", + " num_test=2371\n", + " elif subj==4:\n", + " num_test=2188\n", + " elif subj==6:\n", + " num_test=2371\n", + " elif subj==8:\n", + " num_test=2188\n", + " else:\n", + " num_test=3000\n", + " test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\n", + "print(test_url)\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\n", + "print(f\"Loaded test dl for subj{subj}!\\n\")\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c13b4b84-094c-4b5b-bace-26c155aa6181", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'# Load 73k NSD images\\nf = h5py.File(f\\'{data_path}/coco_images_224_float16.hdf5\\', \\'r\\')\\nimages = f[\\'images\\']\\nprint(\"Loaded all 73k possible NSD images to cpu!\", images.shape)'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"# Load 73k NSD images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images']\n", + "print(\"Loaded all 73k possible NSD images to cpu!\", images.shape)\"\"\"" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + ")\n", + "clip_img_embedder.to(device)\n", + "\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1664" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " from diffusers import AutoencoderKL \n", + " autoenc = AutoencoderKL(\n", + " down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'],\n", + " up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'],\n", + " block_out_channels=[128, 256, 512, 512],\n", + " layers_per_block=2,\n", + " sample_size=256,\n", + " )\n", + " ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth')\n", + " autoenc.load_state_dict(ckpt)\n", + " \n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)\n", + " \n", + " from autoencoder.convnext import ConvnextXL\n", + " cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth')\n", + " cnx.requires_grad_(False)\n", + " cnx.eval()\n", + " cnx.to(device)\n", + " \n", + " mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1)\n", + " std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1)\n", + " \n", + " blur_augs = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8),\n", + " kornia.augmentation.RandomGrayscale(p=0.1),\n", + " kornia.augmentation.RandomSolarize(p=0.1),\n", + " kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0),\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "178,196,480 total\n", + "178,196,480 trainable\n", + "param counts:\n", + "178,196,480 total\n", + "178,196,480 trainable\n", + "torch.Size([2, 1, 174019]) torch.Size([2, 1, 1024])\n" + ] + } + ], + "source": [ + "num_voxels_list = [voxels1.shape[-1]]\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer to enable regularization\n", + " def __init__(self, input_sizes, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linears = torch.nn.ModuleList([\n", + " torch.nn.Linear(input_size, out_features) for input_size in input_sizes\n", + " ])\n", + " def forward(self, x, subj_idx):\n", + " out = self.linears[subj_idx](x[:,0]).unsqueeze(1)\n", + " return out\n", + " \n", + "model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "# test on subject 1 with fake data\n", + "b = torch.randn((2,1,num_voxels_list[0]))\n", + "print(b.shape, model.ridge(b,0).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7b8de65a-6d3b-4248-bea9-9b6f4d562321", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "453,360,280 total\n", + "453,360,280 trainable\n", + "param counts:\n", + "631,556,760 total\n", + "631,556,760 trainable\n", + "b.shape torch.Size([2, 1, 1024])\n", + "torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "from models import BrainNetwork\n", + "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks,\n", + " clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, \n", + " blurry_recon=blurry_recon, clip_scale=clip_scale)\n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((2,1,hidden_dim))\n", + "print(\"b.shape\",b.shape)\n", + "\n", + "backbone_, clip_, blur_ = model.backbone(b)\n", + "print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)" + ] + }, + { + "cell_type": "markdown", + "id": "b397c0d7-52a3-4153-823b-c27d2eb3eeba", + "metadata": {}, + "source": [ + "### Adding diffusion prior + unCLIP if use_prior=True" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "69965344-9346-4592-9cc5-e537e31d5fce", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "259,865,216 total\n", + "259,865,200 trainable\n", + "param counts:\n", + "891,421,976 total\n", + "891,421,960 trainable\n" + ] + } + ], + "source": [ + "if use_prior:\n", + " from models import *\n", + "\n", + " # setup diffusion prior network\n", + " out_dim = clip_emb_dim\n", + " depth = 6\n", + " dim_head = 52\n", + " heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n", + " timesteps = 100\n", + "\n", + " prior_network = PriorNetwork(\n", + " dim=out_dim,\n", + " depth=depth,\n", + " dim_head=dim_head,\n", + " heads=heads,\n", + " causal=False,\n", + " num_tokens = clip_seq_dim,\n", + " learned_query_mode=\"pos_emb\"\n", + " )\n", + "\n", + " model.diffusion_prior = BrainDiffusionPrior(\n", + " net=prior_network,\n", + " image_embed_dim=out_dim,\n", + " condition_on_text_encodings=False,\n", + " timesteps=timesteps,\n", + " cond_drop_prob=0.2,\n", + " image_embed_scale=None,\n", + " )\n", + " \n", + " utils.count_params(model.diffusion_prior)\n", + " utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "ec25271a-2209-400c-8026-df3b8ddc1eef", + "metadata": {}, + "source": [ + "### Setup optimizer / lr / ckpt saving" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 98400\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "891,421,976 total\n", + "891,421,960 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "if use_prior:\n", + " opt_grouped_parameters.extend([\n", + " {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n", + " ])\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag):\n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " if accelerator.is_main_process:\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " print(f\"\\n---saved {outdir}/{tag} ckpt!---\\n\")\n", + "\n", + "def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): \n", + " print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " state_dict = checkpoint['model_state_dict']\n", + " if multisubj_loading: # remove incompatible ridge layer that will otherwise error\n", + " state_dict.pop('ridge.linears.0.weight',None)\n", + " model.load_state_dict(state_dict, strict=strict)\n", + " if load_epoch:\n", + " globals()[\"epoch\"] = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " if load_optimizer:\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " if load_lr:\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " del checkpoint\n", + "\n", + "print(\"\\nDone with model preparations!\")\n", + "num_params = utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "e671cfe9-3a30-461f-bfea-511ff34839b3", + "metadata": {}, + "outputs": [], + "source": [ + "num_test = 370" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb bold5000 run testingbold5000\n", + "wandb_config:\n", + " {'model_name': 'testingbold5000', 'global_batch_size': 8, 'batch_size': 8, 'num_epochs': 150, 'num_sessions': 14, 'num_params': 891421960, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 5254, 'num_test': 370, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n", + "wandb_id: testingbold5000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.19.0 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.17.1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241207_162441-testingbold5000" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Resuming run testingbold5000 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/bold5000" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/bold5000/runs/testingbold5000" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'bold5000'\n", + " print(f\"wandb {wandb_project} run {model_name}\")\n", + " # need to configure wandb beforehand in terminal with \"wandb init\"!\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"num_sessions\": num_sessions,\n", + " \"num_params\": num_params,\n", + " \"clip_scale\": clip_scale,\n", + " \"prior_scale\": prior_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_samples_per_epoch\": num_samples_per_epoch,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id=model_name,\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " resume=\"allow\",\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "607a7c7b-fe5e-41a4-80bf-d2814b3a57cc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# load multisubject stage1 ckpt if set\n", + "if multisubject_ckpt is not None:\n", + " load_ckpt(\"last\",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#train_dls = [train_dl[f'subj0{s}'] for s in subj_list]\n", + "images_train = images1[0:-370]\n", + "images_test = images1[-370::]\n", + "voxels_train = voxels1[0:-370]\n", + "voxels_test = voxels1[-370::]\n", + "\n", + "model, optimizer, images_train, images_test, voxels_train, voxels_test, lr_scheduler = accelerator.prepare(model, optimizer, images_train, images_test, voxels_train, voxels_test, lr_scheduler)\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "testingbold5000 starting with epoch 0 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 55%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 83/150 [1:58:25<1:35:35, 85.61s/it, test/blurry_pixcorr=0, test/loss=19.9, test/loss_clip_total=6.55, test/loss_prior=0.443, test/num_steps=83, test/recon_cossim=0, test/recon_mse=0, test/test_bwd_pct_correct=0.0162, test/test_fwd_pct_correct=0.0108, train/blurry_pixcorr=0, train/bwd_pct_correct=0.999, train/fwd_pct_correct=0.999, train/loss=7.47, train/loss_blurry_cont_total=0, train/loss_blurry_total=0, train/loss_clip_total=0.00171, train/loss_prior=0.249, train/lr=0.000146, train/num_steps=50630, train/recon_cossim=0.813, train/recon_mse=0.249]\n" + ] + }, + { + "ename": "ValueError", + "evalue": "NaN loss", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[26], line 174\u001b[0m\n\u001b[1;32m 171\u001b[0m pixcorr \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mpixcorr(image[random_samps], blurry_recon_images)\n\u001b[1;32m 172\u001b[0m blurry_pixcorr \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m pixcorr\u001b[38;5;241m.\u001b[39mitem()\n\u001b[0;32m--> 174\u001b[0m \u001b[43mutils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 175\u001b[0m accelerator\u001b[38;5;241m.\u001b[39mbackward(loss)\n\u001b[1;32m 176\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n", + "File \u001b[0;32m/weka/proj-fmri/ckadirt/MindEyeV2/src/utils.py:209\u001b[0m, in \u001b[0;36mcheck_loss\u001b[0;34m(loss)\u001b[0m\n\u001b[1;32m 207\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcheck_loss\u001b[39m(loss):\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m loss\u001b[38;5;241m.\u001b[39misnan()\u001b[38;5;241m.\u001b[39many():\n\u001b[0;32m--> 209\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mNaN loss\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: NaN loss" + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + "\n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + " \n", + " recon_cossim = 0.\n", + " test_recon_cossim = 0.\n", + " recon_mse = 0.\n", + " test_recon_mse = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_blurry_cont_total = 0.\n", + " test_loss_clip_total = 0.\n", + " \n", + " loss_prior_total = 0.\n", + " test_loss_prior_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + "\n", + " # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch)\n", + " voxel_iters = {} # empty dict because diff subjects have differing # of voxels\n", + " image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float()\n", + " annot_iters = {}\n", + " perm_iters, betas_iters, select_iters = {}, {}, {}\n", + " \"\"\"for s, train_dl in enumerate(train_dls):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " iter = -1\n", + " for behav0, past_behav0, future_behav0, old_behav0 in train_dl: \n", + " # Load images to cpu from hdf5 (requires sorted indexing)\n", + " image_idx = behav0[:,0,0].cpu().long().numpy()\n", + " image0, image_sorted_idx = np.unique(image_idx, return_index=True) \n", + " if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing\n", + " continue\n", + " iter += 1\n", + " image0 = torch.tensor(images[image0], dtype=data_type)\n", + " image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0\n", + " \n", + " # Load voxels for current batch, matching above indexing\n", + " voxel_idx = behav0[:,0,5].cpu().long().numpy()\n", + " voxel_sorted_idx = voxel_idx[image_sorted_idx]\n", + " voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx]\n", + " voxel0 = torch.Tensor(voxel0).unsqueeze(1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel0, perm, betas, select = utils.mixco(voxel0)\n", + " perm_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = perm\n", + " betas_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = betas\n", + " select_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = select\n", + "\n", + " voxel_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = voxel0\n", + "\n", + " if iter >= num_iterations_per_epoch-1:\n", + " break\"\"\"\n", + "\n", + " # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each\n", + " for train_i in range(int((len(voxels1)-370)/batch_size)):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " random_numbers = [random.randint(0, len(voxels_train)-1) for _ in range(batch_size)]\n", + " optimizer.zero_grad()\n", + " loss=0.\n", + "\n", + " #voxel_list = [voxel_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " #image = image_iters[train_i].detach()\n", + "\n", + " image = images_train[random_numbers]#.unsqueeze(0)\n", + " image = image.to(device)\n", + " #print(image.shape)\n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + "\n", + " clip_target = clip_img_embedder(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + "\n", + " if False: #epoch < int(mixup_pct * num_epochs):\n", + " perm_list = [perm_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " perm = torch.cat(perm_list, dim=0)\n", + " betas_list = [betas_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " betas = torch.cat(betas_list, dim=0)\n", + " select_list = [select_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " select = torch.cat(select_list, dim=0)\n", + "\n", + " voxel = voxels_train[random_numbers].unsqueeze(1).to(device)\n", + " #print(voxel.shape)\n", + " #voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\n", + " #voxel_ridge = torch.cat(voxel_ridge_list, dim=0)\n", + " voxel_ridge = model.ridge(voxel,0)\n", + "\n", + " backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if use_prior:\n", + " loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)\n", + " loss_prior_total += loss_prior.item()\n", + " loss_prior *= prior_scale\n", + " loss += loss_prior\n", + "\n", + " recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()\n", + " recon_mse += mse(prior_out, clip_target).item()\n", + "\n", + " if clip_scale>0:\n", + " if False: #epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006,\n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " loss += loss_clip\n", + "\n", + " if blurry_recon: \n", + " image_enc_pred, transformer_feats = blurry_image_enc_\n", + "\n", + " image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215\n", + " loss_blurry = l1(image_enc_pred, image_enc)\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " if False: #epoch < int(mixup_pct * num_epochs):\n", + " image_enc_shuf = image_enc[perm]\n", + " betas_shape = [-1] + [1]*(len(image_enc.shape)-1)\n", + " image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \\\n", + " image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)\n", + "\n", + " image_norm = (image - mean)/std\n", + " image_aug = (blur_augs(image) - mean)/std\n", + " _, cnx_embeds = cnx(image_norm)\n", + " _, cnx_aug_embeds = cnx(image_aug)\n", + "\n", + " cont_loss = utils.soft_cont_loss(\n", + " nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " temp=0.2)\n", + " loss_blurry_cont_total += cont_loss.item()\n", + "\n", + " loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " blurry_pixcorr += pixcorr.item()\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + "\n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i in range(1):\n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " # assert len(behav) == num_test\n", + "\n", + " ## Average same-image repeats ##\n", + " if False: #test_image is None:\n", + " voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + "\n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if len(locs)==1:\n", + " locs = locs.repeat(3)\n", + " elif len(locs)==2:\n", + " locs = locs.repeat(2)[:3]\n", + " assert len(locs)==3\n", + " if test_image is None:\n", + " test_image = torch.Tensor(images[im][None])\n", + " test_voxel = voxel[locs][None]\n", + " else:\n", + " test_image = torch.vstack((test_image, torch.Tensor(images[im][None])))\n", + " test_voxel = torch.vstack((test_voxel, voxel[locs][None]))\n", + "\n", + " loss=0.\n", + " \n", + " #test_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = voxels_test.to(device).unsqueeze(1)\n", + " image = images_test.to(device)\n", + " #assert len(image) == 300\n", + "\n", + " clip_target = clip_img_embedder(image.float())\n", + "\n", + " voxel_ridge = model.ridge(voxel,0) # 0th index of subj_list\n", + " backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " #for rep in range(3):\n", + " # voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list\n", + " # backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " # if rep==0:\n", + " # clip_voxels = clip_voxels0\n", + " # backbone = backbone0\n", + " # else:\n", + " # clip_voxels += clip_voxels0\n", + " # backbone += backbone0\n", + " #clip_voxels /= 3\n", + " #backbone /= 3\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " # for some evals, only doing a subset of the samples per batch because of computational cost\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " \n", + " if use_prior:\n", + " loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps])\n", + " test_loss_prior_total += loss_prior.item()\n", + " loss_prior *= prior_scale\n", + " loss += loss_prior\n", + " \n", + " if clip_scale>0:\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss += loss_clip\n", + "\n", + " if blurry_recon:\n", + " image_enc_pred, _ = blurry_image_enc_\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + " \n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"train/loss_blurry_cont_total\": loss_blurry_cont_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/recon_cossim\": recon_cossim / (train_i + 1),\n", + " \"test/recon_cossim\": test_recon_cossim / (test_i + 1),\n", + " \"train/recon_mse\": recon_mse / (train_i + 1),\n", + " \"test/recon_mse\": test_recon_mse / (test_i + 1),\n", + " \"train/loss_prior\": loss_prior_total / (train_i + 1),\n", + " \"test/loss_prior\": test_loss_prior_total / (test_i + 1),\n", + " }\n", + "\n", + " # if finished training, save jpg recons if they exist\n", + " if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):\n", + " if blurry_recon: \n", + " image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + "\n", + " if wandb_log:\n", + " logs[f\"test/blur_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " if wandb_log: wandb.log(logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if (ckpt_saving) and (epoch % ckpt_interval == 0):\n", + " save_ckpt(f'last')\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e2fce4d-56aa-46dc-92e9-a15f80d0646b", + "metadata": {}, + "outputs": [], + "source": [ + "losses" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7e81ae3-171f-40ad-a3e8-24bee4472325", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fmri", + "language": "python", + "name": "fmri" + }, + "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.11.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/TrainCluster-Copy2.ipynb b/MindEyeV2/src/TrainCluster-Copy2.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ef58132786a464f778b8a4da48a8155d9edcf01c --- /dev/null +++ b/MindEyeV2/src/TrainCluster-Copy2.ipynb @@ -0,0 +1,1910 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f9cdfdb2-a81e-495f-a777-31acd22d9746", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top-1 Precision: 0.00%\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "def classPrecision(logits, y_true, top=1):\n", + " \"\"\"\n", + " Calculate the precision of the top-n predictions.\n", + " \n", + " Parameters:\n", + " logits (torch.Tensor): The output logits from the model (shape: [batch_size, num_classes]).\n", + " y_true (torch.Tensor): The ground truth labels (shape: [batch_size]).\n", + " top (int): The number of top predictions to consider.\n", + " \n", + " Returns:\n", + " float: The precision percentage of the top-n predictions.\n", + " \"\"\"\n", + " # Apply softmax to get probabilities\n", + " probs = F.softmax(logits, dim=1).detach().cpu()\n", + " \n", + " # Get the top-n predictions\n", + " top_n_preds = torch.topk(probs, top, dim=1).indices.detach().cpu()\n", + "\n", + " # Move y_true to CPU and detach\n", + " y_true = y_true.detach().cpu()\n", + "\n", + " # Check if y_true is in top-n predictions\n", + " correct = top_n_preds.eq(y_true.view(-1, 1).expand_as(top_n_preds))\n", + "\n", + " # Calculate precision\n", + " precision = correct.sum().item() / y_true.size(0)\n", + " \n", + " return precision * 100\n", + "\n", + "# Example usage:\n", + "logits = torch.randn(8, 41) # Example logits tensor\n", + "y_true = torch.randint(0, 41, (8,)) # Example ground truth labels\n", + "\n", + "top_n_precision = classPrecision(logits, y_true, top=1)\n", + "print(f\"Top-1 Precision: {top_n_precision:.2f}%\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "data_type = torch.float16 # change depending on your mixed_precision\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "# First use \"accelerate config\" in terminal and setup using deepspeed stage 2 with CPU offloading!\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job\n", + " global_batch_size = batch_size = 16\n", + "else:\n", + " global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + " batch_size = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 5887\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: fp16\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0 or not distributed: num_devices = 1\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: testing-tt3\n", + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=testing-tt3 --no-multi_subject --subj=1 --batch_size=16 --num_sessions=40 --hidden_dim=1024 --clip_scale=1. --no-blurry_recon --blur_scale=.5 --use_prior --prior_scale=30 --n_blocks=4 --max_lr=1e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug --ckpt_interval=999 --no-ckpt_saving --wandb_log\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"testing-tt3\"\n", + " print(\"model_name:\", model_name)\n", + " \n", + " # global_batch_size and batch_size should already be defined in the 2nd cell block\n", + " jupyter_args = f\"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --cache_dir=/weka/proj-medarc/shared/cache \\\n", + " --model_name={model_name} \\\n", + " --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=40 \\\n", + " --hidden_dim=1024 --clip_scale=1. \\\n", + " --no-blurry_recon --blur_scale=.5 \\\n", + " --use_prior --prior_scale=30 \\\n", + " --n_blocks=4 --max_lr=1e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \\\n", + " --ckpt_interval=999 --no-ckpt_saving --wandb_log\"\n", + " # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow\n", + "\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj_list [1] num_sessions 40\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing2\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Validate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multisubject_ckpt\", type=str, default=None,\n", + " help=\"Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_sessions\", type=int, default=1,\n", + " help=\"Number of training sessions to include\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_prior\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=16,\n", + " help=\"Batch size can be increased by 10x if only training retreival submodule and not diffusion prior\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=.5,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--prior_scale\",type=float,default=30,\n", + " help=\"multiply diffusion prior loss by this\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=150,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multi_subject\",action=argparse.BooleanOptionalAction,default=False,\n", + ")\n", + "parser.add_argument(\n", + " \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_blocks\",type=int,default=4,\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=1024,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-5,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)\n", + "\n", + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + " \n", + "if use_image_aug or blurry_recon:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + "if use_image_aug:\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )\n", + " \n", + "if multi_subject:\n", + " subj_list = np.arange(1,9)\n", + " subj_list = subj_list[subj_list != subj]\n", + "else:\n", + " subj_list = [subj]\n", + "\n", + "print(\"subj_list\", subj_list, \"num_sessions\", num_sessions)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2fb18bf3-27f5-470c-be05-002215d391b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1e-05" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max_lr" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "### Creating wds dataloader, preload betas and all 73k possible images" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aefe7c27-ab39-4b2c-90f4-480f4087b7ab", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dividing batch size by subj_list, which will then be concatenated across subj during training...\n", + "batch_size = 16 num_iterations_per_epoch = 1875 num_samples_per_epoch = 30000\n" + ] + } + ], + "source": [ + "def my_split_by_node(urls): return urls\n", + "num_voxels_list = []\n", + "\n", + "if multi_subject:\n", + " nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])\n", + " num_samples_per_epoch = (750*40) // num_devices \n", + "else:\n", + " num_samples_per_epoch = (750*num_sessions) // num_devices \n", + "\n", + "print(\"dividing batch size by subj_list, which will then be concatenated across subj during training...\") \n", + "batch_size = batch_size // len(subj_list)\n", + "\n", + "num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))\n", + "\n", + "print(\"batch_size =\", batch_size, \"num_iterations_per_epoch =\",num_iterations_per_epoch, \"num_samples_per_epoch =\",num_samples_per_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training with 40 sessions\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar\n", + "num_voxels for subj01: 15724\n", + "Loaded all subj train dls and betas!\n", + "\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar\n", + "Loaded test dl for subj1!\n", + "\n" + ] + } + ], + "source": [ + "train_data = {}\n", + "train_dl = {}\n", + "num_voxels = {}\n", + "voxels = {}\n", + "for s in subj_list:\n", + " print(f\"Training with {num_sessions} sessions\")\n", + " if multi_subject:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{nsessions_allsubj[s-1]-1}\" + \"}.tar\"\n", + " else:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{num_sessions-1}\" + \"}.tar\"\n", + " print(train_url)\n", + " \n", + " train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + " train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + " f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r')\n", + " betas = f['betas'][:]\n", + " betas = torch.Tensor(betas).to(\"cpu\").to(data_type)\n", + " num_voxels_list.append(betas[0].shape[-1])\n", + " num_voxels[f'subj0{s}'] = betas[0].shape[-1]\n", + " voxels[f'subj0{s}'] = betas\n", + " print(f\"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}\")\n", + "\n", + "print(\"Loaded all subj train dls and betas!\\n\")\n", + "\n", + "# Validate only on one subject\n", + "if multi_subject: \n", + " subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list\n", + "if not new_test: # using old test set from before full dataset released (used in original MindEye paper)\n", + " if subj==3:\n", + " num_test=2113\n", + " elif subj==4:\n", + " num_test=1985\n", + " elif subj==6:\n", + " num_test=2113\n", + " elif subj==8:\n", + " num_test=1985\n", + " else:\n", + " num_test=2770\n", + " test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "elif new_test: # using larger test set from after full dataset released\n", + " if subj==3:\n", + " num_test=2371\n", + " elif subj==4:\n", + " num_test=2188\n", + " elif subj==6:\n", + " num_test=2371\n", + " elif subj==8:\n", + " num_test=2188\n", + " else:\n", + " num_test=3000\n", + " test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\n", + "print(test_url)\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\n", + "print(f\"Loaded test dl for subj{subj}!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c13b4b84-094c-4b5b-bace-26c155aa6181", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded all 73k possible NSD images to cpu! (73000, 3, 224, 224)\n" + ] + } + ], + "source": [ + "# Load 73k NSD images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images']\n", + "print(\"Loaded all 73k possible NSD images to cpu!\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + ")\n", + "clip_img_embedder.to(device)\n", + "\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1664" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " from diffusers import AutoencoderKL \n", + " autoenc = AutoencoderKL(\n", + " down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'],\n", + " up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'],\n", + " block_out_channels=[128, 256, 512, 512],\n", + " layers_per_block=2,\n", + " sample_size=256,\n", + " )\n", + " ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth')\n", + " autoenc.load_state_dict(ckpt)\n", + " \n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)\n", + " \n", + " from autoencoder.convnext import ConvnextXL\n", + " cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth')\n", + " cnx.requires_grad_(False)\n", + " cnx.eval()\n", + " cnx.to(device)\n", + " \n", + " mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1)\n", + " std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1)\n", + " \n", + " blur_augs = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8),\n", + " kornia.augmentation.RandomGrayscale(p=0.1),\n", + " kornia.augmentation.RandomSolarize(p=0.1),\n", + " kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0),\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "16,102,400 total\n", + "16,102,400 trainable\n", + "param counts:\n", + "16,102,400 total\n", + "16,102,400 trainable\n", + "torch.Size([2, 1, 15724]) torch.Size([2, 1, 1024])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer to enable regularization\n", + " def __init__(self, input_sizes, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linears = torch.nn.ModuleList([\n", + " torch.nn.Linear(input_size, out_features) for input_size in input_sizes\n", + " ])\n", + " def forward(self, x, subj_idx):\n", + " out = self.linears[subj_idx](x[:,0]).unsqueeze(1)\n", + " return out\n", + " \n", + "class IndividRidgeRegression(torch.nn.Module):\n", + " def __init__(self, input_size, out_features):\n", + " super(IndividRidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " out = self.linear(x)\n", + " return out\n", + " \n", + "model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "# test on subject 1 with fake data\n", + "b = torch.randn((2,1,num_voxels_list[0]))\n", + "print(b.shape, model.ridge(b,0).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7b8de65a-6d3b-4248-bea9-9b6f4d562321", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "453,360,280 total\n", + "453,360,280 trainable\n", + "param counts:\n", + "469,462,680 total\n", + "469,462,680 trainable\n", + "b.shape torch.Size([2, 1, 1024])\n", + "torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "from models import BrainNetwork\n", + "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks,\n", + " clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, \n", + " blurry_recon=blurry_recon, clip_scale=clip_scale)\n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((2,1,hidden_dim))\n", + "print(\"b.shape\",b.shape)\n", + "\n", + "backbone_, clip_, blur_ = model.backbone(b)\n", + "print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)" + ] + }, + { + "cell_type": "markdown", + "id": "e63b26a9-3a36-4638-be3c-dbf28705dd76", + "metadata": {}, + "source": [ + "### Load semantic clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2950add9-3828-4d55-bbf7-0d9f3519de5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "semantic_cluster_onehot.shape torch.Size([73000, 41])\n", + "num_seman_clusters 41\n" + ] + } + ], + "source": [ + "path_semantic_names = \"/weka/proj-medarc/shared/mindeyev2_dataset/semantic_cluster_names.npy\"\n", + "path_semantic_cluster = \"/weka/proj-fmri/ckadirt/MindEyeV2/src/COCO_73k_semantic_cluster.npy\"\n", + "semantic_cluster_names = np.load(path_semantic_names)\n", + "semantic_cluster = np.load(path_semantic_cluster)\n", + "possible_semantic_clusters = np.unique(semantic_cluster)\n", + "\n", + "# one-hot encode semantic clusters\n", + "# move possible_semantic_clusters to numbers and create a dictionary\n", + "semantic_cluster_dict = {cluster: i for i, cluster in enumerate(possible_semantic_clusters)}\n", + "semantic_cluster_onehot = torch.zeros((len(semantic_cluster), len(possible_semantic_clusters)))\n", + "for i, cluster in enumerate(semantic_cluster):\n", + " semantic_cluster_onehot[i, semantic_cluster_dict[cluster]] = 1\n", + "\n", + "\n", + "print(\"semantic_cluster_onehot.shape\", semantic_cluster_onehot.shape)\n", + "\n", + "num_seman_clusters = len(np.unique(semantic_cluster))\n", + "print(\"num_seman_clusters\", num_seman_clusters)" + ] + }, + { + "cell_type": "markdown", + "id": "b397c0d7-52a3-4153-823b-c27d2eb3eeba", + "metadata": {}, + "source": [ + "### Adding the ridge regression to the class" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "69965344-9346-4592-9cc5-e537e31d5fce", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "17,465,385 total\n", + "17,465,385 trainable\n", + "param counts:\n", + "486,928,065 total\n", + "486,928,065 trainable\n" + ] + }, + { + "data": { + "text/plain": [ + "486928065" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# if use_prior:\n", + "# from models import *\n", + "\n", + "# # setup diffusion prior network\n", + "# out_dim = clip_emb_dim\n", + "# depth = 6\n", + "# dim_head = 52\n", + "# heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n", + "# timesteps = 100\n", + "\n", + "# prior_network = PriorNetwork(\n", + "# dim=out_dim,\n", + "# depth=depth,\n", + "# dim_head=dim_head,\n", + "# heads=heads,\n", + "# causal=False,\n", + "# num_tokens = clip_seq_dim,\n", + "# learned_query_mode=\"pos_emb\"\n", + "# )\n", + "\n", + "# model.diffusion_prior = BrainDiffusionPrior(\n", + "# net=prior_network,\n", + "# image_embed_dim=out_dim,\n", + "# condition_on_text_encodings=False,\n", + "# timesteps=timesteps,\n", + "# cond_drop_prob=0.2,\n", + "# image_embed_scale=None,\n", + "# )\n", + " \n", + "# utils.count_params(model.diffusion_prior)\n", + "# utils.count_params(model)\n", + "\n", + "model.RRClassifier = IndividRidgeRegression(clip_emb_dim*clip_seq_dim, out_features=num_seman_clusters)\n", + "utils.count_params(model.RRClassifier)\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "ec25271a-2209-400c-8026-df3b8ddc1eef", + "metadata": {}, + "source": [ + "### Setup optimizer / lr / ckpt saving" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 281250\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "486,928,065 total\n", + "486,928,065 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.RRClassifier.named_parameters()], 'weight_decay': 1e-2},\n", + "]\n", + "# if use_prior:\n", + "# opt_grouped_parameters.extend([\n", + "# {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + "# {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n", + "# ])\n", + "# opt_grouped_parameters.extend([\n", + "# \n", + "# ])\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag):\n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " if accelerator.is_main_process:\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " print(f\"\\n---saved {outdir}/{tag} ckpt!---\\n\")\n", + "\n", + "def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): \n", + " print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " state_dict = checkpoint['model_state_dict']\n", + " if multisubj_loading: # remove incompatible ridge layer that will otherwise error\n", + " state_dict.pop('ridge.linears.0.weight',None)\n", + " model.load_state_dict(state_dict, strict=strict)\n", + " if load_epoch:\n", + " globals()[\"epoch\"] = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " if load_optimizer:\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " if load_lr:\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " del checkpoint\n", + "\n", + "print(\"\\nDone with model preparations!\")\n", + "num_params = utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeye_semantic_cluster run testing-tt3\n", + "wandb_config:\n", + " {'model_name': 'testing-tt3', 'global_batch_size': 16, 'batch_size': 16, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 486928065, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 1e-05, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'}\n", + "wandb_id: testing-tt3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.17.4 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.17.1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_011732-testing-tt3" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run testing-tt3 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeye_semantic_cluster" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeye_semantic_cluster/runs/testing-tt3" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'mindeye_semantic_cluster'\n", + " print(f\"wandb {wandb_project} run {model_name}\")\n", + " # need to configure wandb beforehand in terminal with \"wandb init\"!\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"num_sessions\": num_sessions,\n", + " \"num_params\": num_params,\n", + " \"clip_scale\": clip_scale,\n", + " \"prior_scale\": prior_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_samples_per_epoch\": num_samples_per_epoch,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " \"train_url\": train_url,\n", + " \"test_url\": test_url,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.login(host='https://stability.wandb.io')\n", + " wandb.init(\n", + " id=model_name,\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " resume=\"allow\",\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "607a7c7b-fe5e-41a4-80bf-d2814b3a57cc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# load multisubject stage1 ckpt if set\n", + "if multisubject_ckpt is not None:\n", + " load_ckpt(\"last\",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "train_dls = [train_dl[f'subj0{s}'] for s in subj_list]\n", + "\n", + "model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot = accelerator.prepare(model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot)\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e16fa583-064c-4cfa-9f47-08d08f53f504", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1875\n" + ] + } + ], + "source": [ + "print(num_iterations_per_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "testing-tt3 starting with epoch 4 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/146 [00:00 90\u001b[0m image \u001b[38;5;241m=\u001b[39m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m use_image_aug: \n\u001b[1;32m 93\u001b[0m image \u001b[38;5;241m=\u001b[39m img_augment(image)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + "\n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + " \n", + " recon_cossim = 0.\n", + " test_recon_cossim = 0.\n", + " recon_mse = 0.\n", + " test_recon_mse = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_blurry_cont_total = 0.\n", + " test_loss_clip_total = 0.\n", + " \n", + " loss_prior_total = 0.\n", + " test_loss_prior_total = 0.\n", + " \n", + " loss_RR_total = 0.\n", + " test_loss_RR_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + "\n", + " class_precisions_1 = 0\n", + " test_class_precisions_1 = 0\n", + "\n", + " class_precisions_5 = 0\n", + " test_class_precisions_5 = 0\n", + "\n", + " class_precisions_10 = 0\n", + " test_class_precisions_10 = 0\n", + "\n", + " # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch)\n", + " voxel_iters = {} # empty dict because diff subjects have differing # of voxels\n", + " image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float()\n", + " annot_iters = {}\n", + " perm_iters, betas_iters, select_iters = {}, {}, {}\n", + " images_indexes = {}\n", + " for s, train_dl in enumerate(train_dls):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " iter = -1\n", + " for behav0, past_behav0, future_behav0, old_behav0 in train_dl: \n", + " # Load images to cpu from hdf5 (requires sorted indexing)\n", + " image_idx = behav0[:,0,0].cpu().long().numpy()\n", + "\n", + " image0, image_sorted_idx = np.unique(image_idx, return_index=True) \n", + " if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing\n", + " continue\n", + " iter += 1\n", + " image0 = torch.tensor(images[image0], dtype=data_type)\n", + " image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0\n", + " images_indexes[f\"subj0{s}_iter{iter}\"] = image_sorted_idx\n", + " \n", + " # Load voxels for current batch, matching above indexing\n", + " voxel_idx = behav0[:,0,5].cpu().long().numpy()\n", + " voxel_sorted_idx = voxel_idx[image_sorted_idx]\n", + " voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx]\n", + " voxel0 = torch.Tensor(voxel0).unsqueeze(1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel0, perm, betas, select = utils.mixco(voxel0)\n", + " perm_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = perm\n", + " betas_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = betas\n", + " select_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = select\n", + "\n", + " voxel_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = voxel0\n", + "\n", + " if iter >= num_iterations_per_epoch-1:\n", + " break\n", + "\n", + " # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each\n", + " for train_i in range(num_iterations_per_epoch):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " optimizer.zero_grad()\n", + " loss=0.\n", + "\n", + " voxel_list = [voxel_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " image = image_iters[train_i].detach()\n", + " image = image.to(device)\n", + "\n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + "\n", + " clip_target = clip_img_embedder(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " perm_list = [perm_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " perm = torch.cat(perm_list, dim=0)\n", + " betas_list = [betas_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " betas = torch.cat(betas_list, dim=0)\n", + " select_list = [select_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " select = torch.cat(select_list, dim=0)\n", + "\n", + " voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\n", + " voxel_ridge = torch.cat(voxel_ridge_list, dim=0)\n", + "\n", + " backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " # if use_prior:\n", + " # loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)\n", + " # loss_prior_total += loss_prior.item()\n", + " # loss_prior *= prior_scale\n", + " # loss += loss_prior\n", + "\n", + " # recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()\n", + " # recon_mse += mse(prior_out, clip_target).item()\n", + " print(backbone.shape)\n", + " logits = model.RRClassifier(backbone.flatten(1))\n", + " print(logits.shape)\n", + " print(semantic_cluster[images_indexes[f\"subj0{s}_iter{train_i}\"]])\n", + " print(torch.Tensor([semantic_cluster_dict[i] for i in semantic_cluster[images_indexes[f\"subj0{s}_iter{train_i}\"]]]))\n", + " #print(logits.shape, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).shape)\n", + " #print(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1))\n", + " loss_RR = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).to(logits.device))\n", + " #print(\"backbone.shape\",backbone.shape, \"clip_voxels.shape\",clip_voxels.shape, \"blurry_image_enc_[0].shape\",blurry_image_enc_[0].shape, \"blurry_image_enc_[1].shape\",blurry_image_enc_[1].shape)\n", + " #something \n", + "\n", + " loss_RR_total += loss_RR.item()\n", + " loss += loss_RR\n", + "\n", + " if (torch.rand(1) < 0.03).item():\n", + " print(\"loss_RR\", loss_RR.item())\n", + "\n", + " if clip_scale>0:\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006,\n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " # loss += loss_clip\n", + "\n", + " if blurry_recon: \n", + " image_enc_pred, transformer_feats = blurry_image_enc_\n", + "\n", + " image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215\n", + " loss_blurry = l1(image_enc_pred, image_enc)\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " image_enc_shuf = image_enc[perm]\n", + " betas_shape = [-1] + [1]*(len(image_enc.shape)-1)\n", + " image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \\\n", + " image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)\n", + "\n", + " image_norm = (image - mean)/std\n", + " image_aug = (blur_augs(image) - mean)/std\n", + " _, cnx_embeds = cnx(image_norm)\n", + " _, cnx_aug_embeds = cnx(image_aug)\n", + "\n", + " cont_loss = utils.soft_cont_loss(\n", + " nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " temp=0.2)\n", + " loss_blurry_cont_total += cont_loss.item()\n", + "\n", + " # loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " blurry_pixcorr += pixcorr.item()\n", + "\n", + " class_precisions_1 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).to(logits.device))\n", + " class_precisions_5 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).to(logits.device), 5)\n", + " class_precisions_10 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).to(logits.device), 10)\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + "\n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " assert len(behav) == num_test\n", + "\n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + "\n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if len(locs)==1:\n", + " locs = locs.repeat(3)\n", + " elif len(locs)==2:\n", + " locs = locs.repeat(2)[:3]\n", + " assert len(locs)==3\n", + " if test_image is None:\n", + " test_image = torch.Tensor(images[im][None])\n", + " test_voxel = voxel[locs][None]\n", + " else:\n", + " test_image = torch.vstack((test_image, torch.Tensor(images[im][None])))\n", + " test_voxel = torch.vstack((test_voxel, voxel[locs][None]))\n", + "\n", + " loss=0.\n", + " \n", + " test_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = test_voxel[test_indices].to(device)\n", + " image = test_image[test_indices].to(device)\n", + " assert len(image) == 300\n", + "\n", + " clip_target = clip_img_embedder(image.float())\n", + "\n", + " for rep in range(3):\n", + " voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list\n", + " backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + "\n", + " logits0 = model.RRClassifier(backbone0.flatten(1))\n", + "\n", + " if rep==0:\n", + " clip_voxels = clip_voxels0\n", + " backbone = backbone0\n", + " logits = logits0\n", + " else:\n", + " clip_voxels += clip_voxels0\n", + " backbone += backbone0\n", + " logits += logits0\n", + " clip_voxels /= 3\n", + " backbone /= 3\n", + " logits /= 3\n", + "\n", + " print(logits.shape, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).shape)\n", + " RR_loss = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device))\n", + " test_loss_RR_total += RR_loss.item()\n", + " loss += RR_loss\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " # for some evals, only doing a subset of the samples per batch because of computational cost\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " \n", + " # if use_prior:\n", + " # loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps])\n", + " # test_loss_prior_total += loss_prior.item()\n", + " # loss_prior *= prior_scale\n", + " # loss += loss_prior\n", + " \n", + " if clip_scale>0:\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss += loss_clip\n", + "\n", + " if blurry_recon:\n", + " image_enc_pred, _ = blurry_image_enc_\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " test_class_precisions_1 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device))\n", + " test_class_precisions_5 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device), 5)\n", + " test_class_precisions_10 += classPrecision(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device), 10)\n", + "\n", + " \n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"train/loss_blurry_cont_total\": loss_blurry_cont_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/recon_cossim\": recon_cossim / (train_i + 1),\n", + " \"test/recon_cossim\": test_recon_cossim / (test_i + 1),\n", + " \"train/recon_mse\": recon_mse / (train_i + 1),\n", + " \"test/recon_mse\": test_recon_mse / (test_i + 1),\n", + " \"train/loss_prior\": loss_prior_total / (train_i + 1),\n", + " \"test/loss_prior\": test_loss_prior_total / (test_i + 1),\n", + " \"train/loss_RR\": loss_RR_total / (train_i + 1),\n", + " \"test/loss_RR\": test_loss_RR_total / (test_i + 1),\n", + " \"train/class_precisions_1\": class_precisions_1 / (train_i + 1),\n", + " \"test/class_precisions_1\": test_class_precisions_1 / (test_i + 1),\n", + " \"train/class_precisions_5\": class_precisions_5 / (train_i + 1),\n", + " \"test/class_precisions_5\": test_class_precisions_5 / (test_i + 1),\n", + " \"train/class_precisions_10\": class_precisions_10 / (train_i + 1),\n", + " \"test/class_precisions_10\": test_class_precisions_10 / (test_i + 1),\n", + " }\n", + "\n", + " # if finished training, save jpg recons if they exist\n", + " if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):\n", + " if blurry_recon: \n", + " image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + "\n", + " if wandb_log:\n", + " logs[f\"test/blur_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " if wandb_log: wandb.log(logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if (ckpt_saving) and (epoch % ckpt_interval == 0):\n", + " save_ckpt(f'last')\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "4211dd56-6a12-493e-8ccf-9b5229195cbd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'photo of a person': 0,\n", + " 'photo of airplane': 1,\n", + " 'photo of baseball': 2,\n", + " 'photo of bathroom': 3,\n", + " 'photo of bear': 4,\n", + " 'photo of bedroom': 5,\n", + " 'photo of bike': 6,\n", + " 'photo of bird': 7,\n", + " 'photo of boat': 8,\n", + " 'photo of bus': 9,\n", + " 'photo of cat': 10,\n", + " 'photo of clocktower': 11,\n", + " 'photo of computer': 12,\n", + " 'photo of cow': 13,\n", + " 'photo of dog': 14,\n", + " 'photo of elephant': 15,\n", + " 'photo of flower': 16,\n", + " 'photo of food': 17,\n", + " 'photo of fruits': 18,\n", + " 'photo of giraffe': 19,\n", + " 'photo of group of people': 20,\n", + " 'photo of horse': 21,\n", + " 'photo of hydrant': 22,\n", + " 'photo of living room': 23,\n", + " 'photo of person eating': 24,\n", + " 'photo of pizza': 25,\n", + " 'photo of sheep': 26,\n", + " 'photo of skate': 27,\n", + " 'photo of ski': 28,\n", + " 'photo of sky': 29,\n", + " 'photo of soccer': 30,\n", + " 'photo of sports': 31,\n", + " 'photo of stop sign': 32,\n", + " 'photo of surfer': 33,\n", + " 'photo of sweets': 34,\n", + " 'photo of tennis': 35,\n", + " 'photo of toy': 36,\n", + " 'photo of train': 37,\n", + " 'photo of umbrella': 38,\n", + " 'photo of vehicle': 39,\n", + " 'photo of zebra': 40}" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "semantic_cluster_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7e81ae3-171f-40ad-a3e8-24bee4472325", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45d5bc17-0914-43a5-bb4e-d98f0ba238f0", + "metadata": {}, + "outputs": [], + "source": [ + "import wandb\n", + "wandb.login()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/TrainCluster.ipynb b/MindEyeV2/src/TrainCluster.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f45b26b36c38e615769056ecb8115a9d177a9631 --- /dev/null +++ b/MindEyeV2/src/TrainCluster.ipynb @@ -0,0 +1,1785 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "data_type = torch.float16 # change depending on your mixed_precision\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "# First use \"accelerate config\" in terminal and setup using deepspeed stage 2 with CPU offloading!\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job\n", + " global_batch_size = batch_size = 8\n", + "else:\n", + " global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + " batch_size = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 1132958\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: fp16\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0 or not distributed: num_devices = 1\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: testing2\n", + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=testing2 --no-multi_subject --subj=1 --batch_size=8 --num_sessions=40 --hidden_dim=1024 --clip_scale=1. --no-blurry_recon --blur_scale=.5 --use_prior --prior_scale=30 --n_blocks=4 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug --ckpt_interval=999 --no-ckpt_saving --wandb_log\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"testing2\"\n", + " print(\"model_name:\", model_name)\n", + " \n", + " # global_batch_size and batch_size should already be defined in the 2nd cell block\n", + " jupyter_args = f\"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --cache_dir=/weka/proj-medarc/shared/cache \\\n", + " --model_name={model_name} \\\n", + " --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=40 \\\n", + " --hidden_dim=1024 --clip_scale=1. \\\n", + " --no-blurry_recon --blur_scale=.5 \\\n", + " --use_prior --prior_scale=30 \\\n", + " --n_blocks=4 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \\\n", + " --ckpt_interval=999 --no-ckpt_saving --wandb_log\"\n", + " # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow\n", + "\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj_list [1] num_sessions 40\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing2\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Validate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multisubject_ckpt\", type=str, default=None,\n", + " help=\"Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_sessions\", type=int, default=1,\n", + " help=\"Number of training sessions to include\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_prior\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=16,\n", + " help=\"Batch size can be increased by 10x if only training retreival submodule and not diffusion prior\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=.5,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--prior_scale\",type=float,default=30,\n", + " help=\"multiply diffusion prior loss by this\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=150,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--multi_subject\",action=argparse.BooleanOptionalAction,default=False,\n", + ")\n", + "parser.add_argument(\n", + " \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_blocks\",type=int,default=4,\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=1024,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-5,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)\n", + "\n", + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + " \n", + "if use_image_aug or blurry_recon:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + "if use_image_aug:\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )\n", + " \n", + "if multi_subject:\n", + " subj_list = np.arange(1,9)\n", + " subj_list = subj_list[subj_list != subj]\n", + "else:\n", + " subj_list = [subj]\n", + "\n", + "print(\"subj_list\", subj_list, \"num_sessions\", num_sessions)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2fb18bf3-27f5-470c-be05-002215d391b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3e-05" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max_lr" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "### Creating wds dataloader, preload betas and all 73k possible images" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "aefe7c27-ab39-4b2c-90f4-480f4087b7ab", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dividing batch size by subj_list, which will then be concatenated across subj during training...\n", + "batch_size = 8 num_iterations_per_epoch = 3750 num_samples_per_epoch = 30000\n" + ] + } + ], + "source": [ + "def my_split_by_node(urls): return urls\n", + "num_voxels_list = []\n", + "\n", + "if multi_subject:\n", + " nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])\n", + " num_samples_per_epoch = (750*40) // num_devices \n", + "else:\n", + " num_samples_per_epoch = (750*num_sessions) // num_devices \n", + "\n", + "print(\"dividing batch size by subj_list, which will then be concatenated across subj during training...\") \n", + "batch_size = batch_size // len(subj_list)\n", + "\n", + "num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))\n", + "\n", + "print(\"batch_size =\", batch_size, \"num_iterations_per_epoch =\",num_iterations_per_epoch, \"num_samples_per_epoch =\",num_samples_per_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training with 40 sessions\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar\n", + "num_voxels for subj01: 15724\n", + "Loaded all subj train dls and betas!\n", + "\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar\n", + "Loaded test dl for subj1!\n", + "\n" + ] + } + ], + "source": [ + "train_data = {}\n", + "train_dl = {}\n", + "num_voxels = {}\n", + "voxels = {}\n", + "for s in subj_list:\n", + " print(f\"Training with {num_sessions} sessions\")\n", + " if multi_subject:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{nsessions_allsubj[s-1]-1}\" + \"}.tar\"\n", + " else:\n", + " train_url = f\"{data_path}/wds/subj0{s}/train/\" + \"{0..\" + f\"{num_sessions-1}\" + \"}.tar\"\n", + " print(train_url)\n", + " \n", + " train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + " train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + " f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r')\n", + " betas = f['betas'][:]\n", + " betas = torch.Tensor(betas).to(\"cpu\").to(data_type)\n", + " num_voxels_list.append(betas[0].shape[-1])\n", + " num_voxels[f'subj0{s}'] = betas[0].shape[-1]\n", + " voxels[f'subj0{s}'] = betas\n", + " print(f\"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}\")\n", + "\n", + "print(\"Loaded all subj train dls and betas!\\n\")\n", + "\n", + "# Validate only on one subject\n", + "if multi_subject: \n", + " subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list\n", + "if not new_test: # using old test set from before full dataset released (used in original MindEye paper)\n", + " if subj==3:\n", + " num_test=2113\n", + " elif subj==4:\n", + " num_test=1985\n", + " elif subj==6:\n", + " num_test=2113\n", + " elif subj==8:\n", + " num_test=1985\n", + " else:\n", + " num_test=2770\n", + " test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "elif new_test: # using larger test set from after full dataset released\n", + " if subj==3:\n", + " num_test=2371\n", + " elif subj==4:\n", + " num_test=2188\n", + " elif subj==6:\n", + " num_test=2371\n", + " elif subj==8:\n", + " num_test=2188\n", + " else:\n", + " num_test=3000\n", + " test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\n", + "print(test_url)\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\n", + "print(f\"Loaded test dl for subj{subj}!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c13b4b84-094c-4b5b-bace-26c155aa6181", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded all 73k possible NSD images to cpu! (73000, 3, 224, 224)\n" + ] + } + ], + "source": [ + "# Load 73k NSD images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images']\n", + "print(\"Loaded all 73k possible NSD images to cpu!\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + ")\n", + "clip_img_embedder.to(device)\n", + "\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1664" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " from diffusers import AutoencoderKL \n", + " autoenc = AutoencoderKL(\n", + " down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'],\n", + " up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'],\n", + " block_out_channels=[128, 256, 512, 512],\n", + " layers_per_block=2,\n", + " sample_size=256,\n", + " )\n", + " ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth')\n", + " autoenc.load_state_dict(ckpt)\n", + " \n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)\n", + " \n", + " from autoencoder.convnext import ConvnextXL\n", + " cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth')\n", + " cnx.requires_grad_(False)\n", + " cnx.eval()\n", + " cnx.to(device)\n", + " \n", + " mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1)\n", + " std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1)\n", + " \n", + " blur_augs = AugmentationSequential(\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8),\n", + " kornia.augmentation.RandomGrayscale(p=0.1),\n", + " kornia.augmentation.RandomSolarize(p=0.1),\n", + " kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0),\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "16,102,400 total\n", + "16,102,400 trainable\n", + "param counts:\n", + "16,102,400 total\n", + "16,102,400 trainable\n", + "torch.Size([2, 1, 15724]) torch.Size([2, 1, 1024])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer to enable regularization\n", + " def __init__(self, input_sizes, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linears = torch.nn.ModuleList([\n", + " torch.nn.Linear(input_size, out_features) for input_size in input_sizes\n", + " ])\n", + " def forward(self, x, subj_idx):\n", + " out = self.linears[subj_idx](x[:,0]).unsqueeze(1)\n", + " return out\n", + " \n", + "class IndividRidgeRegression(torch.nn.Module):\n", + " def __init__(self, input_size, out_features):\n", + " super(IndividRidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " out = self.linear(x)\n", + " return out\n", + " \n", + "model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "# test on subject 1 with fake data\n", + "b = torch.randn((2,1,num_voxels_list[0]))\n", + "print(b.shape, model.ridge(b,0).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7b8de65a-6d3b-4248-bea9-9b6f4d562321", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "453,360,280 total\n", + "453,360,280 trainable\n", + "param counts:\n", + "469,462,680 total\n", + "469,462,680 trainable\n", + "b.shape torch.Size([2, 1, 1024])\n", + "torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "from models import BrainNetwork\n", + "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks,\n", + " clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, \n", + " blurry_recon=blurry_recon, clip_scale=clip_scale)\n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((2,1,hidden_dim))\n", + "print(\"b.shape\",b.shape)\n", + "\n", + "backbone_, clip_, blur_ = model.backbone(b)\n", + "print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)" + ] + }, + { + "cell_type": "markdown", + "id": "e63b26a9-3a36-4638-be3c-dbf28705dd76", + "metadata": {}, + "source": [ + "### Load semantic clusters" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2950add9-3828-4d55-bbf7-0d9f3519de5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "semantic_cluster_onehot.shape torch.Size([73024, 41])\n", + "num_seman_clusters 41\n" + ] + } + ], + "source": [ + "path_semantic_names = \"/weka/proj-medarc/shared/mindeyev2_dataset/semantic_cluster_names.npy\"\n", + "path_semantic_cluster = \"/weka/proj-medarc/shared/mindeyev2_dataset/COCO_73k_semantic_cluster.npy\"\n", + "semantic_cluster_names = np.load(path_semantic_names)\n", + "semantic_cluster = np.load(path_semantic_cluster)\n", + "possible_semantic_clusters = np.unique(semantic_cluster)\n", + "\n", + "# one-hot encode semantic clusters\n", + "# move possible_semantic_clusters to numbers and create a dictionary\n", + "semantic_cluster_dict = {cluster: i for i, cluster in enumerate(possible_semantic_clusters)}\n", + "semantic_cluster_onehot = torch.zeros((len(semantic_cluster), len(possible_semantic_clusters)))\n", + "for i, cluster in enumerate(semantic_cluster):\n", + " semantic_cluster_onehot[i, semantic_cluster_dict[cluster]] = 1\n", + "\n", + "\n", + "print(\"semantic_cluster_onehot.shape\", semantic_cluster_onehot.shape)\n", + "\n", + "num_seman_clusters = len(np.unique(semantic_cluster))\n", + "print(\"num_seman_clusters\", num_seman_clusters)" + ] + }, + { + "cell_type": "markdown", + "id": "b397c0d7-52a3-4153-823b-c27d2eb3eeba", + "metadata": {}, + "source": [ + "### Adding the ridge regression to the class" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "69965344-9346-4592-9cc5-e537e31d5fce", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "17,465,385 total\n", + "17,465,385 trainable\n", + "param counts:\n", + "486,928,065 total\n", + "486,928,065 trainable\n" + ] + }, + { + "data": { + "text/plain": [ + "486928065" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# if use_prior:\n", + "# from models import *\n", + "\n", + "# # setup diffusion prior network\n", + "# out_dim = clip_emb_dim\n", + "# depth = 6\n", + "# dim_head = 52\n", + "# heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n", + "# timesteps = 100\n", + "\n", + "# prior_network = PriorNetwork(\n", + "# dim=out_dim,\n", + "# depth=depth,\n", + "# dim_head=dim_head,\n", + "# heads=heads,\n", + "# causal=False,\n", + "# num_tokens = clip_seq_dim,\n", + "# learned_query_mode=\"pos_emb\"\n", + "# )\n", + "\n", + "# model.diffusion_prior = BrainDiffusionPrior(\n", + "# net=prior_network,\n", + "# image_embed_dim=out_dim,\n", + "# condition_on_text_encodings=False,\n", + "# timesteps=timesteps,\n", + "# cond_drop_prob=0.2,\n", + "# image_embed_scale=None,\n", + "# )\n", + " \n", + "# utils.count_params(model.diffusion_prior)\n", + "# utils.count_params(model)\n", + "\n", + "model.RRClassifier = IndividRidgeRegression(clip_emb_dim*clip_seq_dim, out_features=num_seman_clusters)\n", + "utils.count_params(model.RRClassifier)\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "ec25271a-2209-400c-8026-df3b8ddc1eef", + "metadata": {}, + "source": [ + "### Setup optimizer / lr / ckpt saving" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 562500\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "486,928,065 total\n", + "486,928,065 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "# if use_prior:\n", + "# opt_grouped_parameters.extend([\n", + "# {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + "# {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n", + "# ])\n", + "opt_grouped_parameters.extend([\n", + " {'params': [p for n, p in model.RRClassifier.named_parameters()], 'weight_decay': 1e-2},\n", + "])\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag):\n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " if accelerator.is_main_process:\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " print(f\"\\n---saved {outdir}/{tag} ckpt!---\\n\")\n", + "\n", + "def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): \n", + " print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " state_dict = checkpoint['model_state_dict']\n", + " if multisubj_loading: # remove incompatible ridge layer that will otherwise error\n", + " state_dict.pop('ridge.linears.0.weight',None)\n", + " model.load_state_dict(state_dict, strict=strict)\n", + " if load_epoch:\n", + " globals()[\"epoch\"] = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " if load_optimizer:\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " if load_lr:\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " del checkpoint\n", + "\n", + "print(\"\\nDone with model preparations!\")\n", + "num_params = utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeye_semantic_cluster run testing2\n", + "wandb_config:\n", + " {'model_name': 'testing2', 'global_batch_size': 8, 'batch_size': 8, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 486928065, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 3e-05, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'}\n", + "wandb_id: testing2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.17.2 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.17.1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_133545-testing2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Resuming run testing2 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeye_semantic_cluster" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeye_semantic_cluster/runs/testing2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'mindeye_semantic_cluster'\n", + " print(f\"wandb {wandb_project} run {model_name}\")\n", + " # need to configure wandb beforehand in terminal with \"wandb init\"!\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"num_sessions\": num_sessions,\n", + " \"num_params\": num_params,\n", + " \"clip_scale\": clip_scale,\n", + " \"prior_scale\": prior_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_samples_per_epoch\": num_samples_per_epoch,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " \"train_url\": train_url,\n", + " \"test_url\": test_url,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.login(host='https://stability.wandb.io')\n", + " wandb.init(\n", + " id=model_name,\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " resume=\"allow\",\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "607a7c7b-fe5e-41a4-80bf-d2814b3a57cc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# load multisubject stage1 ckpt if set\n", + "if multisubject_ckpt is not None:\n", + " load_ckpt(\"last\",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "train_dls = [train_dl[f'subj0{s}'] for s in subj_list]\n", + "\n", + "model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot = accelerator.prepare(model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot)\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e16fa583-064c-4cfa-9f47-08d08f53f504", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3750\n" + ] + } + ], + "source": [ + "print(num_iterations_per_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "testing2 starting with epoch 0 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/150 [00:00 188\u001b[0m losses\u001b[38;5;241m.\u001b[39mappend(\u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 189\u001b[0m lrs\u001b[38;5;241m.\u001b[39mappend(optimizer\u001b[38;5;241m.\u001b[39mparam_groups[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlr\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 191\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m lr_scheduler_type \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + "\n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + " \n", + " recon_cossim = 0.\n", + " test_recon_cossim = 0.\n", + " recon_mse = 0.\n", + " test_recon_mse = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_blurry_cont_total = 0.\n", + " test_loss_clip_total = 0.\n", + " \n", + " loss_prior_total = 0.\n", + " test_loss_prior_total = 0.\n", + " \n", + " loss_RR_total = 0.\n", + " test_loss_RR_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + "\n", + " # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch)\n", + " voxel_iters = {} # empty dict because diff subjects have differing # of voxels\n", + " image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float()\n", + " annot_iters = {}\n", + " perm_iters, betas_iters, select_iters = {}, {}, {}\n", + " images_indexes = {}\n", + " for s, train_dl in enumerate(train_dls):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " iter = -1\n", + " for behav0, past_behav0, future_behav0, old_behav0 in train_dl: \n", + " # Load images to cpu from hdf5 (requires sorted indexing)\n", + " image_idx = behav0[:,0,0].cpu().long().numpy()\n", + "\n", + " image0, image_sorted_idx = np.unique(image_idx, return_index=True) \n", + " if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing\n", + " continue\n", + " iter += 1\n", + " image0 = torch.tensor(images[image0], dtype=data_type)\n", + " image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0\n", + " images_indexes[f\"subj0{s}_iter{iter}\"] = image_sorted_idx\n", + " \n", + " # Load voxels for current batch, matching above indexing\n", + " voxel_idx = behav0[:,0,5].cpu().long().numpy()\n", + " voxel_sorted_idx = voxel_idx[image_sorted_idx]\n", + " voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx]\n", + " voxel0 = torch.Tensor(voxel0).unsqueeze(1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel0, perm, betas, select = utils.mixco(voxel0)\n", + " perm_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = perm\n", + " betas_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = betas\n", + " select_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = select\n", + "\n", + " voxel_iters[f\"subj0{subj_list[s]}_iter{iter}\"] = voxel0\n", + "\n", + " if iter >= num_iterations_per_epoch-1:\n", + " break\n", + "\n", + " # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each\n", + " for train_i in range(num_iterations_per_epoch):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " optimizer.zero_grad()\n", + " loss=0.\n", + "\n", + " voxel_list = [voxel_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " image = image_iters[train_i].detach()\n", + " image = image.to(device)\n", + "\n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + "\n", + " clip_target = clip_img_embedder(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " perm_list = [perm_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " perm = torch.cat(perm_list, dim=0)\n", + " betas_list = [betas_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " betas = torch.cat(betas_list, dim=0)\n", + " select_list = [select_iters[f\"subj0{s}_iter{train_i}\"].detach().to(device) for s in subj_list]\n", + " select = torch.cat(select_list, dim=0)\n", + "\n", + " voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\n", + " voxel_ridge = torch.cat(voxel_ridge_list, dim=0)\n", + "\n", + " backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " # if use_prior:\n", + " # loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)\n", + " # loss_prior_total += loss_prior.item()\n", + " # loss_prior *= prior_scale\n", + " # loss += loss_prior\n", + "\n", + " # recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()\n", + " # recon_mse += mse(prior_out, clip_target).item()\n", + "\n", + " logits = model.RRClassifier(backbone.flatten(1))\n", + " #print(logits.shape, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).shape)\n", + " #print(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1))\n", + " loss_RR = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f\"subj0{s}_iter{train_i}\"]], dim=1).to(logits.device))\n", + " #print(\"backbone.shape\",backbone.shape, \"clip_voxels.shape\",clip_voxels.shape, \"blurry_image_enc_[0].shape\",blurry_image_enc_[0].shape, \"blurry_image_enc_[1].shape\",blurry_image_enc_[1].shape)\n", + " #something \n", + "\n", + " loss_RR_total += loss_RR.item()\n", + " loss += loss_RR\n", + "\n", + " if clip_scale>0:\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006,\n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " loss += loss_clip\n", + "\n", + " if blurry_recon: \n", + " image_enc_pred, transformer_feats = blurry_image_enc_\n", + "\n", + " image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215\n", + " loss_blurry = l1(image_enc_pred, image_enc)\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " image_enc_shuf = image_enc[perm]\n", + " betas_shape = [-1] + [1]*(len(image_enc.shape)-1)\n", + " image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \\\n", + " image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)\n", + "\n", + " image_norm = (image - mean)/std\n", + " image_aug = (blur_augs(image) - mean)/std\n", + " _, cnx_embeds = cnx(image_norm)\n", + " _, cnx_aug_embeds = cnx(image_aug)\n", + "\n", + " cont_loss = utils.soft_cont_loss(\n", + " nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n", + " temp=0.2)\n", + " loss_blurry_cont_total += cont_loss.item()\n", + "\n", + " loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " blurry_pixcorr += pixcorr.item()\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + "\n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " assert len(behav) == num_test\n", + "\n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + "\n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if len(locs)==1:\n", + " locs = locs.repeat(3)\n", + " elif len(locs)==2:\n", + " locs = locs.repeat(2)[:3]\n", + " assert len(locs)==3\n", + " if test_image is None:\n", + " test_image = torch.Tensor(images[im][None])\n", + " test_voxel = voxel[locs][None]\n", + " else:\n", + " test_image = torch.vstack((test_image, torch.Tensor(images[im][None])))\n", + " test_voxel = torch.vstack((test_voxel, voxel[locs][None]))\n", + "\n", + " loss=0.\n", + " \n", + " test_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = test_voxel[test_indices].to(device)\n", + " image = test_image[test_indices].to(device)\n", + " assert len(image) == 300\n", + "\n", + " clip_target = clip_img_embedder(image.float())\n", + "\n", + " for rep in range(3):\n", + " voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list\n", + " backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + "\n", + " logits0 = model.RRClassifier(backbone0.flatten(1))\n", + "\n", + " if rep==0:\n", + " clip_voxels = clip_voxels0\n", + " backbone = backbone0\n", + " logits = logits0\n", + " else:\n", + " clip_voxels += clip_voxels0\n", + " backbone += backbone0\n", + " logits += logits0\n", + " clip_voxels /= 3\n", + " backbone /= 3\n", + " logits /= 3\n", + "\n", + " print(logits.shape, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).shape)\n", + " RR_loss = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device))\n", + " test_loss_RR_total += RR_loss.item()\n", + " loss += RR_loss\n", + "\n", + " if clip_scale>0:\n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " # for some evals, only doing a subset of the samples per batch because of computational cost\n", + " random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n", + " \n", + " # if use_prior:\n", + " # loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps])\n", + " # test_loss_prior_total += loss_prior.item()\n", + " # loss_prior *= prior_scale\n", + " # loss += loss_prior\n", + " \n", + " if clip_scale>0:\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss += loss_clip\n", + "\n", + " if blurry_recon:\n", + " image_enc_pred, _ = blurry_image_enc_\n", + " blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if clip_scale>0:\n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + " \n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"train/loss_blurry_cont_total\": loss_blurry_cont_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/recon_cossim\": recon_cossim / (train_i + 1),\n", + " \"test/recon_cossim\": test_recon_cossim / (test_i + 1),\n", + " \"train/recon_mse\": recon_mse / (train_i + 1),\n", + " \"test/recon_mse\": test_recon_mse / (test_i + 1),\n", + " \"train/loss_prior\": loss_prior_total / (train_i + 1),\n", + " \"test/loss_prior\": test_loss_prior_total / (test_i + 1),\n", + " \"train/loss_RR\": loss_RR_total / (train_i + 1),\n", + " \"test/loss_RR\": test_loss_RR_total / (test_i + 1),\n", + " }\n", + "\n", + " # if finished training, save jpg recons if they exist\n", + " if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):\n", + " if blurry_recon: \n", + " image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + "\n", + " if wandb_log:\n", + " logs[f\"test/blur_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " if wandb_log: wandb.log(logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if (ckpt_saving) and (epoch % ckpt_interval == 0):\n", + " save_ckpt(f'last')\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7e81ae3-171f-40ad-a3e8-24bee4472325", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45d5bc17-0914-43a5-bb4e-d98f0ba238f0", + "metadata": {}, + "outputs": [], + "source": [ + "import wandb\n", + "wandb.login()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/TrainCluster.py b/MindEyeV2/src/TrainCluster.py new file mode 100644 index 0000000000000000000000000000000000000000..369b96e824186fd1fa4b19d7f3ce098d2d416db5 --- /dev/null +++ b/MindEyeV2/src/TrainCluster.py @@ -0,0 +1,1078 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Import packages & functions + +# In[1]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm +import webdataset as wds + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from accelerate import Accelerator + +# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main +sys.path.append('generative_models/') +import sgm +from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[2]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +data_type = torch.float16 # change depending on your mixed_precision +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# First use "accelerate config" in terminal and setup using deepspeed stage 2 with CPU offloading! +accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job + global_batch_size = batch_size = 8 +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + + +# In[3]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +num_devices = torch.cuda.device_count() +if num_devices==0 or not distributed: num_devices = 1 +num_workers = num_devices +print(accelerator.state) + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[4]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + model_name = "testing2" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the 2nd cell block + jupyter_args = f"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \ + --cache_dir=/weka/proj-medarc/shared/cache \ + --model_name={model_name} \ + --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=40 \ + --hidden_dim=1024 --clip_scale=1. \ + --no-blurry_recon --blur_scale=.5 \ + --use_prior --prior_scale=30 \ + --n_blocks=4 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \ + --ckpt_interval=999 --no-ckpt_saving --wandb_log" + # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow + + print(jupyter_args) + jupyter_args = jupyter_args.split() + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[5]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing2", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default=os.getcwd(), + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--cache_dir", type=str, default=os.getcwd(), + help="Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8], + help="Validate on which subject?", +) +parser.add_argument( + "--multisubject_ckpt", type=str, default=None, + help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.", +) +parser.add_argument( + "--num_sessions", type=int, default=1, + help="Number of training sessions to include", +) +parser.add_argument( + "--use_prior",action=argparse.BooleanOptionalAction,default=True, + help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)", +) +parser.add_argument( + "--batch_size", type=int, default=16, + help="Batch size can be increased by 10x if only training retreival submodule and not diffusion prior", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=.5, + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--prior_scale",type=float,default=30, + help="multiply diffusion prior loss by this", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=False, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=150, + help="number of epochs of training", +) +parser.add_argument( + "--multi_subject",action=argparse.BooleanOptionalAction,default=False, +) +parser.add_argument( + "--new_test",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--n_blocks",type=int,default=4, +) +parser.add_argument( + "--hidden_dim",type=int,default=1024, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-5, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +# seed all random functions +utils.seed_everything(seed) + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) + +if use_image_aug or blurry_recon: + import kornia + from kornia.augmentation.container import AugmentationSequential +if use_image_aug: + img_augment = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + +if multi_subject: + subj_list = np.arange(1,9) + subj_list = subj_list[subj_list != subj] +else: + subj_list = [subj] + +print("subj_list", subj_list, "num_sessions", num_sessions) + + +# In[6]: + + +max_lr + + +# # Prep data, models, and dataloaders + +# ### Creating wds dataloader, preload betas and all 73k possible images + +# In[7]: + + +def my_split_by_node(urls): return urls +num_voxels_list = [] + +if multi_subject: + nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30]) + num_samples_per_epoch = (750*40) // num_devices +else: + num_samples_per_epoch = (750*num_sessions) // num_devices + +print("dividing batch size by subj_list, which will then be concatenated across subj during training...") +batch_size = batch_size // len(subj_list) + +num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list)) + +print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch) + + +# In[8]: + + +train_data = {} +train_dl = {} +num_voxels = {} +voxels = {} +for s in subj_list: + print(f"Training with {num_sessions} sessions") + if multi_subject: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{nsessions_allsubj[s-1]-1}" + "}.tar" + else: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{num_sessions-1}" + "}.tar" + print(train_url) + + train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) + train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + + f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r') + betas = f['betas'][:] + betas = torch.Tensor(betas).to("cpu").to(data_type) + num_voxels_list.append(betas[0].shape[-1]) + num_voxels[f'subj0{s}'] = betas[0].shape[-1] + voxels[f'subj0{s}'] = betas + print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}") + +print("Loaded all subj train dls and betas!\n") + +# Validate only on one subject +if multi_subject: + subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list +if not new_test: # using old test set from before full dataset released (used in original MindEye paper) + if subj==3: + num_test=2113 + elif subj==4: + num_test=1985 + elif subj==6: + num_test=2113 + elif subj==8: + num_test=1985 + else: + num_test=2770 + test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +elif new_test: # using larger test set from after full dataset released + if subj==3: + num_test=2371 + elif subj==4: + num_test=2188 + elif subj==6: + num_test=2371 + elif subj==8: + num_test=2188 + else: + num_test=3000 + test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" +print(test_url) +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +print(f"Loaded test dl for subj{subj}!\n") + + +# In[9]: + + +# Load 73k NSD images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'] +print("Loaded all 73k possible NSD images to cpu!", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[10]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) + +clip_seq_dim = 256 +clip_emb_dim = 1664 + + +# ### SD VAE + +# In[11]: + + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + from autoencoder.convnext import ConvnextXL + cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth') + cnx.requires_grad_(False) + cnx.eval() + cnx.to(device) + + mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1) + std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1) + + blur_augs = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8), + kornia.augmentation.RandomGrayscale(p=0.1), + kornia.augmentation.RandomSolarize(p=0.1), + kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0), + data_keys=["input"], + ) + + +# ### MindEye modules + +# In[12]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[13]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +class IndividRidgeRegression(torch.nn.Module): + def __init__(self, input_size, out_features): + super(IndividRidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + out = self.linear(x) + return out + +model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +# test on subject 1 with fake data +b = torch.randn((2,1,num_voxels_list[0])) +print(b.shape, model.ridge(b,0).shape) + + +# In[14]: + + +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, + blurry_recon=blurry_recon, clip_scale=clip_scale) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((2,1,hidden_dim)) +print("b.shape",b.shape) + +backbone_, clip_, blur_ = model.backbone(b) +print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape) + + +# ### Load semantic clusters + +# In[15]: + + +path_semantic_names = "/weka/proj-medarc/shared/mindeyev2_dataset/semantic_cluster_names.npy" +path_semantic_cluster = "/weka/proj-medarc/shared/mindeyev2_dataset/COCO_73k_semantic_cluster.npy" +semantic_cluster_names = np.load(path_semantic_names) +semantic_cluster = np.load(path_semantic_cluster) +possible_semantic_clusters = np.unique(semantic_cluster) + +# one-hot encode semantic clusters +# move possible_semantic_clusters to numbers and create a dictionary +semantic_cluster_dict = {cluster: i for i, cluster in enumerate(possible_semantic_clusters)} +semantic_cluster_onehot = torch.zeros((len(semantic_cluster), len(possible_semantic_clusters))) +for i, cluster in enumerate(semantic_cluster): + semantic_cluster_onehot[i, semantic_cluster_dict[cluster]] = 1 + + +print("semantic_cluster_onehot.shape", semantic_cluster_onehot.shape) + +num_seman_clusters = len(np.unique(semantic_cluster)) +print("num_seman_clusters", num_seman_clusters) + + +# ### Adding the ridge regression to the class + +# In[16]: + + +# if use_prior: +# from models import * + +# # setup diffusion prior network +# out_dim = clip_emb_dim +# depth = 6 +# dim_head = 52 +# heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim +# timesteps = 100 + +# prior_network = PriorNetwork( +# dim=out_dim, +# depth=depth, +# dim_head=dim_head, +# heads=heads, +# causal=False, +# num_tokens = clip_seq_dim, +# learned_query_mode="pos_emb" +# ) + +# model.diffusion_prior = BrainDiffusionPrior( +# net=prior_network, +# image_embed_dim=out_dim, +# condition_on_text_encodings=False, +# timesteps=timesteps, +# cond_drop_prob=0.2, +# image_embed_scale=None, +# ) + +# utils.count_params(model.diffusion_prior) +# utils.count_params(model) + +model.RRClassifier = IndividRidgeRegression(clip_emb_dim*clip_seq_dim, out_features=num_seman_clusters) +utils.count_params(model.RRClassifier) +utils.count_params(model) + + +# ### Setup optimizer / lr / ckpt saving + +# In[17]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] + +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] +# if use_prior: +# opt_grouped_parameters.extend([ +# {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, +# {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} +# ]) +opt_grouped_parameters.extend([ + {'params': [p for n, p in model.RRClassifier.named_parameters()], 'weight_decay': 1e-2}, +]) + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*num_iterations_per_epoch)) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + if accelerator.is_main_process: + unwrapped_model = accelerator.unwrap_model(model) + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + print(f"\n---saved {outdir}/{tag} ckpt!---\n") + +def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): + print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + if multisubj_loading: # remove incompatible ridge layer that will otherwise error + state_dict.pop('ridge.linears.0.weight',None) + model.load_state_dict(state_dict, strict=strict) + if load_epoch: + globals()["epoch"] = checkpoint['epoch'] + print("Epoch",epoch) + if load_optimizer: + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + if load_lr: + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + del checkpoint + +print("\nDone with model preparations!") +num_params = utils.count_params(model) + + +# # Weights and Biases + +# In[18]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeye_semantic_cluster' + print(f"wandb {wandb_project} run {model_name}") + # need to configure wandb beforehand in terminal with "wandb init"! + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "num_sessions": num_sessions, + "num_params": num_params, + "clip_scale": clip_scale, + "prior_scale": prior_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_samples_per_epoch": num_samples_per_epoch, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + print("wandb_id:",model_name) + wandb.login(host='https://stability.wandb.io') + wandb.init( + id=model_name, + project=wandb_project, + name=model_name, + config=wandb_config, + resume="allow", + ) +else: + wandb_log = False + + +# # Main + +# In[19]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +torch.cuda.empty_cache() + + +# In[20]: + + +# load multisubject stage1 ckpt if set +if multisubject_ckpt is not None: + load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True) + + +# In[21]: + + +train_dls = [train_dl[f'subj0{s}'] for s in subj_list] + +model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot = accelerator.prepare(model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[22]: + + +print(num_iterations_per_epoch) + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + recon_cossim = 0. + test_recon_cossim = 0. + recon_mse = 0. + test_recon_mse = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_blurry_cont_total = 0. + test_loss_clip_total = 0. + + loss_prior_total = 0. + test_loss_prior_total = 0. + + loss_RR_total = 0. + test_loss_RR_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch) + voxel_iters = {} # empty dict because diff subjects have differing # of voxels + image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float() + annot_iters = {} + perm_iters, betas_iters, select_iters = {}, {}, {} + images_indexes = {} + for s, train_dl in enumerate(train_dls): + with torch.cuda.amp.autocast(dtype=data_type): + iter = -1 + for behav0, past_behav0, future_behav0, old_behav0 in train_dl: + # Load images to cpu from hdf5 (requires sorted indexing) + image_idx = behav0[:,0,0].cpu().long().numpy() + + image0, image_sorted_idx = np.unique(image_idx, return_index=True) + if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing + continue + iter += 1 + image0 = torch.tensor(images[image0], dtype=data_type) + image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0 + images_indexes[f"subj0{s}_iter{iter}"] = image_sorted_idx + + # Load voxels for current batch, matching above indexing + voxel_idx = behav0[:,0,5].cpu().long().numpy() + voxel_sorted_idx = voxel_idx[image_sorted_idx] + voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx] + voxel0 = torch.Tensor(voxel0).unsqueeze(1) + + if epoch < int(mixup_pct * num_epochs): + voxel0, perm, betas, select = utils.mixco(voxel0) + perm_iters[f"subj0{subj_list[s]}_iter{iter}"] = perm + betas_iters[f"subj0{subj_list[s]}_iter{iter}"] = betas + select_iters[f"subj0{subj_list[s]}_iter{iter}"] = select + + voxel_iters[f"subj0{subj_list[s]}_iter{iter}"] = voxel0 + + if iter >= num_iterations_per_epoch-1: + break + + # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each + for train_i in range(num_iterations_per_epoch): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + loss=0. + + voxel_list = [voxel_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + image = image_iters[train_i].detach() + image = image.to(device) + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_img_embedder(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + perm_list = [perm_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + perm = torch.cat(perm_list, dim=0) + betas_list = [betas_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + betas = torch.cat(betas_list, dim=0) + select_list = [select_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + select = torch.cat(select_list, dim=0) + + voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)] + voxel_ridge = torch.cat(voxel_ridge_list, dim=0) + + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # if use_prior: + # loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target) + # loss_prior_total += loss_prior.item() + # loss_prior *= prior_scale + # loss += loss_prior + + # recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item() + # recon_mse += mse(prior_out, clip_target).item() + + logits = model.RRClassifier(backbone.flatten(1)) + #print(logits.shape, torch.argmax(semantic_cluster_onehot[images_indexes[f"subj0{s}_iter{train_i}"]], dim=1).shape) + #print(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f"subj0{s}_iter{train_i}"]], dim=1)) + loss_RR = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f"subj0{s}_iter{train_i}"]], dim=1).to(logits.device)) + #print("backbone.shape",backbone.shape, "clip_voxels.shape",clip_voxels.shape, "blurry_image_enc_[0].shape",blurry_image_enc_[0].shape, "blurry_image_enc_[1].shape",blurry_image_enc_[1].shape) + #something + + loss_RR_total += loss_RR.item() + loss += loss_RR + + if clip_scale>0: + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, transformer_feats = blurry_image_enc_ + + image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215 + loss_blurry = l1(image_enc_pred, image_enc) + loss_blurry_total += loss_blurry.item() + + if epoch < int(mixup_pct * num_epochs): + image_enc_shuf = image_enc[perm] + betas_shape = [-1] + [1]*(len(image_enc.shape)-1) + image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \ + image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape) + + image_norm = (image - mean)/std + image_aug = (blur_augs(image) - mean)/std + _, cnx_embeds = cnx(image_norm) + _, cnx_aug_embeds = cnx(image_aug) + + cont_loss = utils.soft_cont_loss( + nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1), + nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + temp=0.2) + loss_blurry_cont_total += cont_loss.item() + + loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215 + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + blurry_pixcorr += pixcorr.item() + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if len(locs)==1: + locs = locs.repeat(3) + elif len(locs)==2: + locs = locs.repeat(2)[:3] + assert len(locs)==3 + if test_image is None: + test_image = torch.Tensor(images[im][None]) + test_voxel = voxel[locs][None] + else: + test_image = torch.vstack((test_image, torch.Tensor(images[im][None]))) + test_voxel = torch.vstack((test_voxel, voxel[locs][None])) + + loss=0. + + test_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[test_indices].to(device) + image = test_image[test_indices].to(device) + assert len(image) == 300 + + clip_target = clip_img_embedder(image.float()) + + for rep in range(3): + voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list + backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge) + + logits0 = model.RRClassifier(backbone0.flatten(1)) + + if rep==0: + clip_voxels = clip_voxels0 + backbone = backbone0 + logits = logits0 + else: + clip_voxels += clip_voxels0 + backbone += backbone0 + logits += logits0 + clip_voxels /= 3 + backbone /= 3 + logits /= 3 + + print(logits.shape, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).shape) + RR_loss = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device)) + test_loss_RR_total += RR_loss.item() + loss += RR_loss + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # for some evals, only doing a subset of the samples per batch because of computational cost + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + + # if use_prior: + # loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps]) + # test_loss_prior_total += loss_prior.item() + # loss_prior *= prior_scale + # loss += loss_prior + + if clip_scale>0: + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, _ = blurry_image_enc_ + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + test_blurry_pixcorr += pixcorr.item() + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/recon_cossim": recon_cossim / (train_i + 1), + "test/recon_cossim": test_recon_cossim / (test_i + 1), + "train/recon_mse": recon_mse / (train_i + 1), + "test/recon_mse": test_recon_mse / (test_i + 1), + "train/loss_prior": loss_prior_total / (train_i + 1), + "test/loss_prior": test_loss_prior_total / (test_i + 1), + "train/loss_RR": loss_RR_total / (train_i + 1), + "test/loss_RR": test_loss_RR_total / (test_i + 1), + } + + # if finished training, save jpg recons if they exist + if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0): + if blurry_recon: + image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215 + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/blur_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + if wandb_log: wandb.log(logs) + + # Save model checkpoint and reconstruct + if (ckpt_saving) and (epoch % ckpt_interval == 0): + save_ckpt(f'last') + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# In[ ]: + + +import wandb +wandb.login() + diff --git a/MindEyeV2/src/accel.slurm b/MindEyeV2/src/accel.slurm new file mode 100644 index 0000000000000000000000000000000000000000..f0b347f1c195219b0f435dc95625650e5e605061 --- /dev/null +++ b/MindEyeV2/src/accel.slurm @@ -0,0 +1,43 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --qos=normal +#SBATCH --partition=p5 +#SBATCH --job-name=eyeRR +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --time=48:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err # first create a "slurms" folder in current directory to store logs +#SBATCH -o slurms/%j.out +#SBATCH --comment=medarc +#SBATCH --no-requeue +#SBATCH --exclusive + +# Make sure you activate your fmri environment created from src/setup.sh +cd /weka/proj-fmri/ckadirt/MindEyeV2/src +source /admin/home-ckadirt/fmri/bin/activate + +# The following line converts your jupyter notebook into a python script runnable with Slurm +jupyter nbconvert TrainCluster-Copy2.ipynb --to python + +export NUM_GPUS=1 # Set to equal gres=gpu:#! +export BATCH_SIZE=21 # 21 for multisubject / 24 for singlesubject (orig. paper used 42 for multisubject / 24 for singlesubject) +export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=1 #$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +# multisubject pretraining +model_name="rr-test-top" +echo model_name=${model_name} +# accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +python TrainCluster-Copy2.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +# singlesubject finetuning +#model_name="finetuned_subj01_40sess" +#echo model_name=${model_name} +#accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=../train_logs/multisubject_excludingsubj01_40sess diff --git a/MindEyeV2/src/accelSM.slurm b/MindEyeV2/src/accelSM.slurm new file mode 100644 index 0000000000000000000000000000000000000000..bbf45c096cdde74fd2b081c6bcd33298e2b8dc0b --- /dev/null +++ b/MindEyeV2/src/accelSM.slurm @@ -0,0 +1,42 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --qos=normal +#SBATCH --partition=p5 +#SBATCH --job-name=sm_p_msub_0.33 +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --time=48:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err # first create a "slurms" folder in current directory to store logs +#SBATCH -o slurms/%j.out +#SBATCH --comment=medarc +#SBATCH --no-requeue + +# Make sure you activate your fmri environment created from src/setup.sh +cd /weka/proj-fmri/ckadirt/MindEyeV2/src +source /admin/home-ckadirt/fmri/bin/activate + +# The following line converts your jupyter notebook into a python script runnable with Slurm +jupyter nbconvert train_semantic_cluster.ipynb --to python + +export NUM_GPUS=1 # Set to equal gres=gpu:#! +export BATCH_SIZE=21 # 21 for multisubject / 24 for singlesubject (orig. paper used 42 for multisubject / 24 for singlesubject) +export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=1 #$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +# multisubject pretraining +model_name="semantic_cluster_1.2_average_after_wd-2_prior_multi" +echo model_name=${model_name} +# accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +python Untitled1.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --use_prior --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +# singlesubject finetuning +#model_name="finetuned_subj01_40sess" +#echo model_name=${model_name} +#accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=../train_logs/multisubject_excludingsubj01_40sess diff --git a/MindEyeV2/src/accel_recon_imagery.slurm b/MindEyeV2/src/accel_recon_imagery.slurm new file mode 100644 index 0000000000000000000000000000000000000000..8c567238a713fd7997678c8afc2ef97e8a805d9e --- /dev/null +++ b/MindEyeV2/src/accel_recon_imagery.slurm @@ -0,0 +1,58 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=p5 +#SBATCH --job-name=me2_imagery +#SBATCH --ntasks-per-node=1 +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --gpus-per-task=1 # Set to equal gres=gpu:# +#SBATCH --time=72:00:00 # Total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err # Ensure "slurms" directory exists for logs +#SBATCH -o slurms/%j.out +#SBATCH --comment=medarc +#SBATCH --no-requeue +#SBATCH --qos=idle +#SBATCH --dependency=afterok:534007 + +source ~/.bashrc +source /admin/home-ckadirt/fmri/bin/activate +cd /weka/proj-fmri/ckadirt/MindEyeV2/src/ + + +# Set up networking environment variables to avoid port conflicts +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(echo "$HOSTNAMES" | head -n 1) +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" + +export MODULEPATH=/opt/amazon/modules/modulefiles:$MODULEPATH + +jupyter nbconvert enhanced_recon_inference.ipynb --to python +jupyter nbconvert recon_inference.ipynb --to python + +# jupyter nbconvert final_evaluations_mi_multi_icnn.ipynb --to python + + +for subj in 1; do + for num_sessions in 2 3 5 10 20 40; do + model_name="final_subj0${subj}_pretrained_${num_sessions}sess_24bs" + echo ${model_name} + echo "new_sessions" + + for mode in "imagery" "vision"; do # + + python recon_inference.py \ + --data_path=/weka/proj-medarc/shared/mindeyev2_dataset \ + --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset \ + --model_name="${model_name}" --subj=1 \ + --hidden_dim=4096 --n_blocks=4 --new_test \ + --mode="${mode}" \ + --imagery_data_path=/weka/proj-medarc/shared/umn-imagery + + python enhanced_recon_inference.py \ + --model_name="${model_name}" --subj=1 --mode="${mode}" + + done + done + done diff --git a/MindEyeV2/src/accel_recon_shared1000.slurm b/MindEyeV2/src/accel_recon_shared1000.slurm new file mode 100644 index 0000000000000000000000000000000000000000..3f6d22634ae9e7cbda55a67b6d97daba9e80e0da --- /dev/null +++ b/MindEyeV2/src/accel_recon_shared1000.slurm @@ -0,0 +1,53 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=p5 +#SBATCH --job-name=me2_shared1000 +#SBATCH --ntasks-per-node=1 +#SBATCH --nodes=1 +#SBATCH --gres=gpu:1 +#SBATCH --gpus-per-task=1 # Set to equal gres=gpu:# +#SBATCH --time=72:00:00 # Total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err # Ensure "slurms" directory exists for logs +#SBATCH -o slurms/%j.out +#SBATCH --comment=medarc +#SBATCH --no-requeue +#SBATCH --qos=normal + +source ~/.bashrc +source /admin/home-ckadirt/fmri/bin/activate +cd /weka/proj-fmri/ckadirt/MindEyeV2/src/ + + +# Set up networking environment variables to avoid port conflicts +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(echo "$HOSTNAMES" | head -n 1) +echo "MASTER_ADDR=${MASTER_ADDR}" +echo "MASTER_PORT=${MASTER_PORT}" + +export MODULEPATH=/opt/amazon/modules/modulefiles:$MODULEPATH + +jupyter nbconvert enhanced_recon_inference_old.ipynb --to python +jupyter nbconvert recon_inference_old.ipynb --to python + +# jupyter nbconvert final_evaluations_mi_multi_icnn.ipynb --to python + + +for subj in 1; do + for num_sessions in 3; do + model_name="final_subj0${subj}_pretrained_${num_sessions}sess_24bs" + echo ${model_name} + echo "new_sessions" + + + python recon_inference_old.py \ + --data_path=/weka/proj-medarc/shared/mindeyev2_dataset \ + --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset \ + --model_name="${model_name}" --subj=1 \ + --hidden_dim=4096 --n_blocks=4 --new_test + + python enhanced_recon_inference_old.py \ + --model_name="${model_name}" --subj=1 + + done + done diff --git a/MindEyeV2/src/autoencoder/convnext.py b/MindEyeV2/src/autoencoder/convnext.py new file mode 100644 index 0000000000000000000000000000000000000000..76dc8829b1c60fb84150d856c501aae5f8965ede --- /dev/null +++ b/MindEyeV2/src/autoencoder/convnext.py @@ -0,0 +1,239 @@ + +# Copyright (c) Meta Platforms, Inc. and affiliates. + +# All rights reserved. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +import torch +import torch.nn as nn +import torch.nn.functional as F +from timm.models.layers import trunc_normal_, DropPath + + +class Block(nn.Module): + r""" ConvNeXt Block. There are two equivalent implementations: + (1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W) + (2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back + We use (2) as we find it slightly faster in PyTorch + + Args: + dim (int): Number of input channels. + drop_path (float): Stochastic depth rate. Default: 0.0 + layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6. + """ + + def __init__(self, dim, drop_path=0.0, layer_scale_init_value=1e-6): + super().__init__() + self.dwconv = nn.Conv2d( + dim, dim, kernel_size=7, padding=3, groups=dim + ) # depthwise conv + self.norm = LayerNorm(dim, eps=1e-6) + self.pwconv1 = nn.Linear( + dim, 4 * dim + ) # pointwise/1x1 convs, implemented with linear layers + self.act = nn.GELU() + self.pwconv2 = nn.Linear(4 * dim, dim) + self.gamma = ( + nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True) + if layer_scale_init_value > 0 + else None + ) + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + def forward(self, x): + input = x + x = self.dwconv(x) + x = x.permute(0, 2, 3, 1) # (N, C, H, W) -> (N, H, W, C) + x = self.norm(x) + x = self.pwconv1(x) + x = self.act(x) + x = self.pwconv2(x) + if self.gamma is not None: + x = self.gamma * x + x = x.permute(0, 3, 1, 2) # (N, H, W, C) -> (N, C, H, W) + + x = input + self.drop_path(x) + return x + + +class ConvNeXt(nn.Module): + r""" ConvNeXt + A PyTorch impl of : `A ConvNet for the 2020s` - + https://arxiv.org/pdf/2201.03545.pdf + Args: + in_chans (int): Number of input image channels. Default: 3 + num_classes (int): Number of classes for classification head. Default: 1000 + depths (tuple(int)): Number of blocks at each stage. Default: [3, 3, 9, 3] + dims (int): Feature dimension at each stage. Default: [96, 192, 384, 768] + drop_path_rate (float): Stochastic depth rate. Default: 0. + layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6. + head_init_scale (float): Init scaling value for classifier weights and biases. Default: 1. + """ + + def __init__( + self, + in_chans=3, + num_classes=1000, + depths=[3, 3, 9, 3], + dims=[96, 192, 384, 768], + drop_path_rate=0.1, + layer_scale_init_value=0.0, + head_init_scale=1.0, + ): + super().__init__() + + self.downsample_layers = ( + nn.ModuleList() + ) # stem and 3 intermediate downsampling conv layers + stem = nn.Sequential( + nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4), + LayerNorm(dims[0], eps=1e-6, data_format="channels_first"), + ) + self.downsample_layers.append(stem) + for i in range(3): + downsample_layer = nn.Sequential( + LayerNorm(dims[i], eps=1e-6, data_format="channels_first"), + nn.Conv2d(dims[i], dims[i + 1], kernel_size=2, stride=2), + ) + self.downsample_layers.append(downsample_layer) + + self.stages = ( + nn.ModuleList() + ) # 4 feature resolution stages, each consisting of multiple residual blocks + dp_rates = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] + cur = 0 + for i in range(4): + stage = nn.Sequential( + *[ + Block( + dim=dims[i], + drop_path=dp_rates[cur + j], + layer_scale_init_value=layer_scale_init_value, + ) + for j in range(depths[i]) + ] + ) + self.stages.append(stage) + cur += depths[i] + + self.norm = nn.LayerNorm(dims[-1], eps=1e-6) # final norm layer + self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) + + self.apply(self._init_weights) + + def _init_weights(self, m): + if isinstance(m, (nn.Conv2d, nn.Linear)): + trunc_normal_(m.weight, std=0.02) + nn.init.constant_(m.bias, 0) + + def forward_features(self, x): + for i in range(4): + x = self.downsample_layers[i](x) + x = self.stages[i](x) + x = x.flatten(2, 3).permute(0, 2, 1) + x = self.norm(x) + x_avg = x.mean(dim=1) + return x, x_avg + + def forward(self, x): + x = self.forward_features(x) + return x + + +class LayerNorm(nn.Module): + r""" LayerNorm that supports two data formats: channels_last (default) or channels_first. + The ordering of the dimensions in the inputs. channels_last corresponds to inputs with + shape (batch_size, height, width, channels) while channels_first corresponds to inputs + with shape (batch_size, channels, height, width). + """ + + def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"): + super().__init__() + self.weight = nn.Parameter(torch.ones(normalized_shape)) + self.bias = nn.Parameter(torch.zeros(normalized_shape)) + self.eps = eps + self.data_format = data_format + if self.data_format not in ["channels_last", "channels_first"]: + raise NotImplementedError + self.normalized_shape = (normalized_shape,) + + def forward(self, x): + if self.data_format == "channels_last": + return F.layer_norm( + x, self.normalized_shape, self.weight, self.bias, self.eps + ) + elif self.data_format == "channels_first": + u = x.mean(1, keepdim=True) + s = (x - u).pow(2).mean(1, keepdim=True) + x = (x - u) / torch.sqrt(s + self.eps) + x = self.weight[:, None, None] * x + self.bias[:, None, None] + return x + + +def convnext_tiny(**kwargs): + model = ConvNeXt(depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], **kwargs) + return model, 768 + + +def convnext_small(**kwargs): + model = ConvNeXt(depths=[3, 3, 27, 3], dims=[96, 192, 384, 768], **kwargs) + return model, 768 + + +def convnext_base(**kwargs): + model = ConvNeXt(depths=[3, 3, 27, 3], dims=[128, 256, 512, 1024], **kwargs) + return model, 1024 + + +def convnext_large(**kwargs): + model = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536], **kwargs) + return model, 1536 + + +def convnext_xlarge(**kwargs): + model = ConvNeXt(depths=[3, 3, 27, 3], dims=[256, 512, 1024, 2048], **kwargs) + return model, 2048 + +def MLP(mlp, embedding, norm_layer): + mlp_spec = f"{embedding}-{mlp}" + layers = [] + f = list(map(int, mlp_spec.split("-"))) + for i in range(len(f) - 2): + layers.append(nn.Linear(f[i], f[i + 1])) + if norm_layer == "batch_norm": + layers.append(nn.BatchNorm1d(f[i + 1])) + elif norm_layer == "layer_norm": + layers.append(nn.LayerNorm(f[i + 1])) + layers.append(nn.ReLU(True)) + layers.append(nn.Linear(f[-2], f[-1], bias=False)) + return nn.Sequential(*layers) + +class ConvnextXL(torch.nn.Module): + def __init__(self, path): + super().__init__() + self.backbone, _ = convnext_xlarge() + self.maps_projector = MLP('512-512-512', 2048, 'layer_norm') + self.init_weights(path) + + def init_weights(self, path): + sd = torch.load(path, map_location='cpu')['model'] + for k in list(sd.keys()): + if 'module' in k: + sd[k.replace('module.', '')] = sd[k] + del sd[k] + try: + self.load_state_dict(sd, strict=False) + except: + pass + + def forward(self, x): + p, _ = self.backbone(x) # b, hw, 2048 + return p, self.maps_projector(p) + + +if __name__== "__main__": + m = ConvnextXL('../train_logs/models/convnext_xlarge_alpha0.75_fullckpt.pth') + preds = m(torch.randn(2, 3, 512, 512)) diff --git a/MindEyeV2/src/bold5k_preproc.ipynb b/MindEyeV2/src/bold5k_preproc.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..828372b0993790ddf8034939a599788a8b5e8311 --- /dev/null +++ b/MindEyeV2/src/bold5k_preproc.ipynb @@ -0,0 +1,1195 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "5dcd117f-627f-4a21-ae64-3ec6434ec1f6", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import nibabel as nib\n", + "import ants\n", + "import os\n", + "from helpers import *" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "88b4c290-b5f8-42bb-bd1e-186d5cd98fc9", + "metadata": {}, + "outputs": [], + "source": [ + "# read file /weka/proj-medarc/shared/bold5000_open_neuro/ds001499-download/derivatives/fmriprep/sub-CSI1/ses-01/func/sub-CSI1_ses-01_task-5000scenes_run-01_bold_space-T1w_preproc.nii.gz\n", + "base_path = '/weka/proj-medarc/shared/bold5000_open_neuro/'\n", + "# img = nib.load('/weka/proj-medarc/shared/bold5000_open_neuro/ds001499-download/derivatives/fmriprep/sub-CSI1/ses-01/func/sub-CSI1_ses-01_task-5000scenes_run-01_bold_space-T1w_preproc.nii.gz')\n", + "# print(img.shape)\n", + "fmriprep_path = os.path.join(base_path, 'ds001499-download/derivatives/fmriprep/')" + ] + }, + { + "cell_type": "markdown", + "id": "59262ef6-7c32-44a5-b64a-a920b862c081", + "metadata": {}, + "source": [ + "### Plot example image" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "263d3893-3cc1-4a04-b749-38c30863a9d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# raw_sample_img_path = os.path.join(fmriprep_path, \"sub-CSI1/ses-01/func/sub-CSI1_ses-01_task-5000scenes_run-01_bold_space-T1w_preproc.nii.gz\")\n", + "raw_sample_img_path = os.path.join(fmriprep_path, \"sub-CSI1/anat/sub-CSI1_T1w_preproc.nii.gz\")\n", + "raw_img_ants = ants.image_read(raw_sample_img_path)\n", + "ants.plot(raw_img_ants[:,:,:], figsize=1, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "a8eb623c-e083-4d77-a5f1-05a4fa7a0515", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ANTsImage (LPI)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (176, 256, 256)\n", + "\t Spacing : (1.0, 1.0, 1.0)\n", + "\t Origin : (83.2627, 131.7728, -142.5885)\n", + "\t Direction : [-1. 0. 0. 0. -1. 0. 0. 0. 1.]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "raw_img_ants" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "32cb691c-f613-4760-9a86-3898696302a0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a440bc6ee5cd49b1b32723a2c111ac8c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=44, description='SLICE', max=88), Output()), _dom_classes=('widget-inter…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "raw_img_ants_arr = raw_img_ants[:,:,:,0].numpy().transpose(1,2,0)\n", + "explore_3D_array(raw_img_ants_arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2497af41-005b-4723-b34d-23f048a6a4e7", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "97a04613430f422c8d393ad347f4be87", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=90, description='SLICE', max=181), Output()), _dom_classes=('widget-inte…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "template_img_path = os.path.join(base_path, \"MNI152_T1_1mm.nii.gz\")\n", + "template_img_ants = ants.image_read(template_img_path, reorient='IAL')\n", + "\n", + "explore_3D_array(arr = template_img_ants.numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "af5e083d-0ad7-4be5-93f4-817296dcc5d9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "template_img_ants ANTsImage (IAL)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (182, 218, 182)\n", + "\t Spacing : (1.0, 1.0, 1.0)\n", + "\t Origin : (91.0, -91.0, -72.0)\n", + "\t Direction : [ 0. 0. -1. 0. 1. 0. 1. 0. 0.]\n", + " raw_img_ants ANTsImage\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (71, 89, 72, 194)\n", + "\t Spacing : (2.0, 2.0, 2.0, 2.0)\n", + "\t Origin : (67.2627, 113.7728, -60.5885, 0.0)\n", + "\t Direction : [-1. 0. 0. 0. 0. -1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1.]\n", + "\n" + ] + } + ], + "source": [ + "print(\"template_img_ants\", template_img_ants, \"raw_img_ants\", raw_img_ants)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8993f9e2-d1ff-49b6-8360-4b814c456b96", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "d4328a36-aa24-429c-a1ae-70370291776c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mants\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mregistration\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mfixed\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmoving\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtype_of_transform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'SyN'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0minitial_transform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0moutprefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmoving_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmask_all_stages\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mgrad_step\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mflow_sigma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtotal_sigma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_metric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mattes'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_sampling\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m32\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_random_sampling_rate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msyn_metric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mattes'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msyn_sampling\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m32\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mreg_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m40\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_iterations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_shrink_factors\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0maff_smoothing_sigmas\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mwrite_composite_transform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrandom_seed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmultivariate_extras\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrestrict_transformation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msmoothing_in_mm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Register a pair of images either through the full or simplified\n", + "interface to the ANTs registration method.\n", + "\n", + "ANTsR function: `antsRegistration`\n", + "\n", + "Arguments\n", + "---------\n", + "fixed : ANTsImage\n", + " fixed image to which we register the moving image.\n", + "\n", + "moving : ANTsImage\n", + " moving image to be mapped to fixed space.\n", + "\n", + "type_of_transform : string\n", + " A linear or non-linear registration type. Mutual information metric by default.\n", + " See Notes below for more.\n", + "\n", + "initial_transform : list of strings (optional)\n", + " transforms to prepend. If None, a translation is computed to align the image centers of mass.\n", + "\n", + "outprefix : string\n", + " output will be named with this prefix.\n", + "\n", + "mask : ANTsImage (optional)\n", + " Registration metric mask in the fixed image space.\n", + "\n", + "moving_mask : ANTsImage (optional)\n", + " Registration metric mask in the moving image space.\n", + "\n", + "mask_all_stages : boolean\n", + " If true, apply metric mask(s) to all registration stages, instead of just the final stage.\n", + "\n", + "grad_step : scalar\n", + " gradient step size (not for all tx)\n", + "\n", + "flow_sigma : scalar\n", + " smoothing for update field\n", + " At each iteration, the similarity metric and gradient is calculated. \n", + " That gradient field is also called the update field and is smoothed \n", + " before composing with the total field (i.e., the estimate of the total \n", + " transform at that iteration). This total field can also be smoothed \n", + " after each iteration.\n", + "\n", + "total_sigma : scalar\n", + " smoothing for total field\n", + "\n", + "aff_metric : string\n", + " the metric for the affine part (GC, mattes, meansquares)\n", + "\n", + "aff_sampling : scalar\n", + " number of bins for the mutual information metric\n", + "\n", + "aff_random_sampling_rate : scalar\n", + " the fraction of points used to estimate the metric. this can impact\n", + " speed but also reproducibility and/or accuracy.\n", + "\n", + "syn_metric : string\n", + " the metric for the syn part (CC, mattes, meansquares, demons)\n", + "\n", + "syn_sampling : scalar\n", + " the nbins or radius parameter for the syn metric\n", + "\n", + "reg_iterations : list/tuple of integers\n", + " vector of iterations for syn. we will set the smoothing and multi-resolution parameters based on the length of this vector.\n", + "\n", + "aff_iterations : list/tuple of integers\n", + " vector of iterations for low-dimensional (translation, rigid, affine) registration.\n", + "\n", + "aff_shrink_factors : list/tuple of integers\n", + " vector of multi-resolution shrink factors for low-dimensional (translation, rigid, affine) registration.\n", + "\n", + "aff_smoothing_sigmas : list/tuple of integers\n", + " vector of multi-resolution smoothing factors for low-dimensional (translation, rigid, affine) registration.\n", + "\n", + "random_seed : integer\n", + " random seed to improve reproducibility. note that the number of ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS should be 1 if you want perfect reproducibility.\n", + "\n", + "write_composite_transform : boolean\n", + " Boolean specifying whether or not the composite transform (and its inverse, if it exists) should be written to an hdf5 composite file. This is false by default so that only the transform for each stage is written to file.\n", + "\n", + "verbose : boolean\n", + " request verbose output (useful for debugging)\n", + "\n", + "multivariate_extras : additional metrics for multi-metric registration\n", + " list of additional images and metrics which will\n", + " trigger the use of multiple metrics in the registration\n", + " process in the deformable stage. Each multivariate metric needs 5\n", + " entries: name of metric, fixed, moving, weight,\n", + " samplingParam. the list of lists should be of the form ( (\n", + " \"nameOfMetric2\", img, img, weight, metricParam ) ). Another\n", + " example would be ( ( \"MeanSquares\", f2, m2, 0.5, 0\n", + " ), ( \"CC\", f2, m2, 0.5, 2 ) ) . This is only compatible\n", + " with the SyNOnly or antsRegistrationSyN* transformations.\n", + "\n", + "restrict_transformation : This option allows the user to restrict the\n", + " optimization of the displacement field, translation, rigid or\n", + " affine transform on a per-component basis. For example, if\n", + " one wants to limit the deformation or rotation of 3-D volume\n", + " to the first two dimensions, this is possible by specifying a\n", + " weight vector of ‘(1,1,0)’ for a 3D deformation field or\n", + " ‘(1,1,0,1,1,0)’ for a rigid transformation. Restriction\n", + " currently only works if there are no preceding\n", + " transformations.\n", + "\n", + "smoothing_in_mm : boolean ; currently only impacts low dimensional registration\n", + "\n", + "kwargs : keyword args\n", + " extra arguments\n", + "\n", + "Returns\n", + "-------\n", + "dict containing follow key/value pairs:\n", + " `warpedmovout`: Moving image warped to space of fixed image.\n", + " `warpedfixout`: Fixed image warped to space of moving image.\n", + " `fwdtransforms`: Transforms to move from moving to fixed image.\n", + " `invtransforms`: Transforms to move from fixed to moving image.\n", + "\n", + "Notes\n", + "-----\n", + "type_of_transform can be one of:\n", + " - \"Translation\": Translation transformation.\n", + " - \"Rigid\": Rigid transformation: Only rotation and translation.\n", + " - \"Similarity\": Similarity transformation: scaling, rotation and translation.\n", + " - \"QuickRigid\": Rigid transformation: Only rotation and translation.\n", + " May be useful for quick visualization fixes.'\n", + " - \"DenseRigid\": Rigid transformation: Only rotation and translation.\n", + " Employs dense sampling during metric estimation.'\n", + " - \"BOLDRigid\": Rigid transformation: Parameters typical for BOLD to\n", + " BOLD intrasubject registration'.'\n", + " - \"Affine\": Affine transformation: Rigid + scaling.\n", + " - \"AffineFast\": Fast version of Affine.\n", + " - \"BOLDAffine\": Affine transformation: Parameters typical for BOLD to\n", + " BOLD intrasubject registration'.'\n", + " - \"TRSAA\": translation, rigid, similarity, affine (twice). please set\n", + " regIterations if using this option. this would be used in\n", + " cases where you want a really high quality affine mapping\n", + " (perhaps with mask).\n", + " - \"Elastic\": Elastic deformation: Affine + deformable.\n", + " - \"ElasticSyN\": Symmetric normalization: Affine + deformable\n", + " transformation, with mutual information as optimization\n", + " metric and elastic regularization.\n", + " - \"SyN\": Symmetric normalization: Affine + deformable transformation,\n", + " with mutual information as optimization metric.\n", + " - \"SyNRA\": Symmetric normalization: Rigid + Affine + deformable\n", + " transformation, with mutual information as optimization metric.\n", + " - \"SyNOnly\": Symmetric normalization with no rigid or affine stages.\n", + " Uses mutual information as optimization metric. Affine alignment is\n", + " from the initial_transform arg, either provide the .mat from linear\n", + " registration or use initial_transform='Identity' if the images are \n", + " already affinely aligned.\n", + " Can be useful if you want to run an unmasked affine followed by\n", + " masked deformable registration.\n", + " - \"SyNCC\": SyN, but with cross-correlation as the metric.\n", + " - \"SyNabp\": SyN optimized for abpBrainExtraction.\n", + " - \"SyNBold\": SyN, but optimized for registrations between BOLD and T1 images.\n", + " - \"SyNBoldAff\": SyN, but optimized for registrations between BOLD\n", + " and T1 images, with additional affine step.\n", + " - \"SyNAggro\": SyN, but with more aggressive registration\n", + " (fine-scale matching and more deformation).\n", + " Takes more time than SyN.\n", + " - \"TV[n]\": time-varying diffeomorphism with where 'n' indicates number of\n", + " time points in velocity field discretization. The initial transform\n", + " should be computed, if needed, in a separate call to ants.registration.\n", + " - \"TVMSQ\": time-varying diffeomorphism with mean square metric\n", + " - \"TVMSQC\": time-varying diffeomorphism with mean square metric for very large deformation\n", + " - \"antsRegistrationSyN[x]\": recreation of the antsRegistrationSyN.sh script in ANTs\n", + " where 'x' is one of the transforms available (e.g., 't', 'b', 's')\n", + " - \"antsRegistrationSyNQuick[x]\": recreation of the antsRegistrationSyNQuick.sh script in ANTs\n", + " where 'x' is one of the transforms available (e.g., 't', 'b', 's')\n", + " - \"antsRegistrationSyNRepro[x]\": reproducible registration. x options as above.\n", + " - \"antsRegistrationSyNQuickRepro[x]\": quick reproducible registration. x options as above.\n", + "\n", + "Example\n", + "-------\n", + ">>> import ants\n", + ">>> fi = ants.image_read(ants.get_ants_data('r16'))\n", + ">>> mi = ants.image_read(ants.get_ants_data('r64'))\n", + ">>> fi = ants.resample_image(fi, (60,60), 1, 0)\n", + ">>> mi = ants.resample_image(mi, (60,60), 1, 0)\n", + ">>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'SyN' )\n", + ">>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[t]' )\n", + ">>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[b]' )\n", + ">>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[s]' )\n", + "\u001b[0;31mFile:\u001b[0m ~/mei-env/lib/python3.11/site-packages/ants/registration/registration.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ants.registration?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cfb60580-9b18-45e8-b281-e29b4abd6fee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "antsRegistration -d 3 -r [0x7f5e83bfd488,0x7f5e83bfd8e8,1] -m mattes[0x7f5e83bfd488,0x7f5e83bfd8e8,1,32,regular,0.2] -t Affine[0.25] -c 2100x1200x1200x0 -s 3x2x1x0 -f 4x2x2x1 -x [NA,NA] -m mattes[0x7f5e83bfd488,0x7f5e83bfd8e8,1,32] -t SyN[0.200000,3.000000,0.000000] -c [40x20x0,1e-7,8] -s 2x1x0 -f 4x2x1 -u 1 -z 1 -o [/tmp/tmplblaew7e,0x7f5e83bfd708,0x7f5e83bfd4e8] -x [NA,NA] --float 1 --write-composite-transform 0 -v 1\n", + "All_Command_lines_OK\n", + "Using single precision for computations.\n", + "=============================================================================\n", + "The composite transform comprises the following transforms (in order): \n", + " 1. Center of mass alignment using fixed image: 0x7f5e83bfd488 and moving image: 0x7f5e83bfd8e8 (type = Euler3DTransform)\n", + "=============================================================================\n", + " Reading mask(s).\n", + " Registration stage 0\n", + " No fixed mask\n", + " No moving mask\n", + " Registration stage 1\n", + " No fixed mask\n", + " No moving mask\n", + " number of levels = 4\n", + " number of levels = 3\n", + " fixed image: 0x7f5e83bfd488\n", + " moving image: 0x7f5e83bfd8e8\n", + " fixed image: 0x7f5e83bfd488\n", + " moving image: 0x7f5e83bfd8e8\n", + "Dimension = 3\n", + "Number of stages = 2\n", + "Use histogram matching = true\n", + "Winsorize image intensities = false\n", + " Lower quantile = 0\n", + " Upper quantile = 1\n", + "\n", + "\n", + "Stage 1 State\n", + " Image metric = MattesMI\n", + " Fixed image = Image (0x5d3e490)\n", + " RTTI typeinfo: itk::Image\n", + " Reference Count: 2\n", + " Modified Time: 2193\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Source: (none)\n", + " Source output name: (none)\n", + " Release Data: Off\n", + " Data Released: False\n", + " Global Release Data: Off\n", + " PipelineMTime: 0\n", + " UpdateMTime: 2166\n", + " RealTimeStamp: 0 seconds \n", + " LargestPossibleRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " BufferedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " RequestedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " Spacing: [1, 1, 1]\n", + " Origin: [91, -91, -72]\n", + " Direction: \n", + "0 0 -1\n", + "0 1 0\n", + "1 0 0\n", + "\n", + " IndexToPointMatrix: \n", + "0 0 -1\n", + "0 1 0\n", + "1 0 0\n", + "\n", + " PointToIndexMatrix: \n", + "0 0 1\n", + "0 1 0\n", + "-1 0 0\n", + "\n", + " Inverse Direction: \n", + "0 0 1\n", + "0 1 0\n", + "-1 0 0\n", + "\n", + " PixelContainer: \n", + " ImportImageContainer (0x6fd71e0)\n", + " RTTI typeinfo: itk::ImportImageContainer\n", + " Reference Count: 1\n", + " Modified Time: 2164\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Pointer: 0xfdf2e60\n", + " Container manages memory: true\n", + " Size: 7221032\n", + " Capacity: 7221032\n", + "\n", + " Moving image = Image (0x7020970)\n", + " RTTI typeinfo: itk::Image\n", + " Reference Count: 2\n", + " Modified Time: 2194\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Source: (none)\n", + " Source output name: (none)\n", + " Release Data: Off\n", + " Data Released: False\n", + " Global Release Data: Off\n", + " PipelineMTime: 0\n", + " UpdateMTime: 2191\n", + " RealTimeStamp: 0 seconds \n", + " LargestPossibleRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " BufferedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " RequestedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " Spacing: [2, 2, 2]\n", + " Origin: [67.2627, 113.773, -60.5885]\n", + " Direction: \n", + "1 0 0\n", + "0 1 0\n", + "0 0 1\n", + "\n", + " IndexToPointMatrix: \n", + "2 0 0\n", + "0 2 0\n", + "0 0 2\n", + "\n", + " PointToIndexMatrix: \n", + "0.5 0 0\n", + "0 0.5 0\n", + "0 0 0.5\n", + "\n", + " Inverse Direction: \n", + "1 0 0\n", + "0 1 0\n", + "0 0 1\n", + "\n", + " PixelContainer: \n", + " ImportImageContainer (0x7034390)\n", + " RTTI typeinfo: itk::ImportImageContainer\n", + " Reference Count: 1\n", + " Modified Time: 2189\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Pointer: 0x7086b50\n", + " Container manages memory: true\n", + " Size: 454968\n", + " Capacity: 454968\n", + "\n", + " Weighting = 1\n", + " Sampling strategy = regular\n", + " Number of bins = 32\n", + " Radius = 4\n", + " Sampling percentage = 0.2\n", + " Transform = Affine\n", + " Gradient step = 0.25\n", + " Update field sigma (voxel space) = 0\n", + " Total field sigma (voxel space) = 0\n", + " Update field time sigma = 0\n", + " Total field time sigma = 0\n", + " Number of time indices = 0\n", + " Number of time point samples = 0\n", + "Stage 2 State\n", + " Image metric = MattesMI\n", + " Fixed image = Image (0x7020c00)\n", + " RTTI typeinfo: itk::Image\n", + " Reference Count: 2\n", + " Modified Time: 2244\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Source: (none)\n", + " Source output name: (none)\n", + " Release Data: Off\n", + " Data Released: False\n", + " Global Release Data: Off\n", + " PipelineMTime: 0\n", + " UpdateMTime: 2217\n", + " RealTimeStamp: 0 seconds \n", + " LargestPossibleRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " BufferedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " RequestedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [182, 218, 182]\n", + " Spacing: [1, 1, 1]\n", + " Origin: [91, -91, -72]\n", + " Direction: \n", + "0 0 -1\n", + "0 1 0\n", + "1 0 0\n", + "\n", + " IndexToPointMatrix: \n", + "0 0 -1\n", + "0 1 0\n", + "1 0 0\n", + "\n", + " PointToIndexMatrix: \n", + "0 0 1\n", + "0 1 0\n", + "-1 0 0\n", + "\n", + " Inverse Direction: \n", + "0 0 1\n", + "0 1 0\n", + "-1 0 0\n", + "\n", + " PixelContainer: \n", + " ImportImageContainer (0x6eea4e0)\n", + " RTTI typeinfo: itk::ImportImageContainer\n", + " Reference Count: 1\n", + " Modified Time: 2215\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Pointer: 0x1197eb10\n", + " Container manages memory: true\n", + " Size: 7221032\n", + " Capacity: 7221032\n", + "\n", + " Moving image = Image (0x7020e90)\n", + " RTTI typeinfo: itk::Image\n", + " Reference Count: 2\n", + " Modified Time: 2245\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Source: (none)\n", + " Source output name: (none)\n", + " Release Data: Off\n", + " Data Released: False\n", + " Global Release Data: Off\n", + " PipelineMTime: 0\n", + " UpdateMTime: 2242\n", + " RealTimeStamp: 0 seconds \n", + " LargestPossibleRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " BufferedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " RequestedRegion: \n", + " Dimension: 3\n", + " Index: [0, 0, 0]\n", + " Size: [71, 89, 72]\n", + " Spacing: [2, 2, 2]\n", + " Origin: [67.2627, 113.773, -60.5885]\n", + " Direction: \n", + "1 0 0\n", + "0 1 0\n", + "0 0 1\n", + "\n", + " IndexToPointMatrix: \n", + "2 0 0\n", + "0 2 0\n", + "0 0 2\n", + "\n", + " PointToIndexMatrix: \n", + "0.5 0 0\n", + "0 0.5 0\n", + "0 0 0.5\n", + "\n", + " Inverse Direction: \n", + "1 0 0\n", + "0 1 0\n", + "0 0 1\n", + "\n", + " PixelContainer: \n", + " ImportImageContainer (0x7248c40)\n", + " RTTI typeinfo: itk::ImportImageContainer\n", + " Reference Count: 1\n", + " Modified Time: 2240\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Pointer: 0x1350a7c0\n", + " Container manages memory: true\n", + " Size: 454968\n", + " Capacity: 454968\n", + "\n", + " Weighting = 1\n", + " Sampling strategy = none\n", + " Number of bins = 32\n", + " Radius = 4\n", + " Sampling percentage = 1\n", + " Transform = SyN\n", + " Gradient step = 0.2\n", + " Update field sigma (voxel space) = 3\n", + " Total field sigma (voxel space) = 0\n", + " Update field time sigma = 0\n", + " Total field time sigma = 0\n", + " Number of time indices = 0\n", + " Number of time point samples = 0\n", + "Registration using 2 total stages.\n", + "\n", + "Stage 0\n", + " iterations = 2100x1200x1200x0\n", + " convergence threshold = 1e-06\n", + " convergence window size = 10\n", + " number of levels = 4\n", + " using the Mattes MI metric (number of bins = 32, weight = 1, use gradient filter = 0)\n", + " preprocessing: histogram matching the images\n", + " Shrink factors (level 1 out of 4): [4, 4, 4]\n", + " Shrink factors (level 2 out of 4): [2, 2, 2]\n", + " Shrink factors (level 3 out of 4): [2, 2, 2]\n", + " Shrink factors (level 4 out of 4): [1, 1, 1]\n", + " smoothing sigmas per level: [3, 2, 1, 0]\n", + " regular sampling (percentage = 0.2)\n", + "\n", + "*** Running AffineTransform registration ***\n", + "\n", + "DIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 2DIAGNOSTIC, 1, -2.996422648430e-01, inf, 7.7959e-02, 7.7757e-02, \n", + " 2DIAGNOSTIC, 2, -3.017916381359e-01, inf, 8.3032e-02, 5.0731e-03, \n", + " 2DIAGNOSTIC, 3, -3.065226674080e-01, inf, 8.8194e-02, 5.1620e-03, \n", + " 2DIAGNOSTIC, 4, -3.143281936646e-01, inf, 9.3941e-02, 5.7468e-03, \n", + " 2DIAGNOSTIC, 5, -3.262019753456e-01, inf, 1.0166e-01, 7.7150e-03, \n", + " 2DIAGNOSTIC, 6, -3.472766578197e-01, inf, 1.0671e-01, 5.0550e-03, \n", + " 2DIAGNOSTIC, 7, -3.658357858658e-01, inf, 1.1154e-01, 4.8242e-03, \n", + " 2DIAGNOSTIC, 8, -3.831660449505e-01, inf, 1.1709e-01, 5.5590e-03, \n", + " 2DIAGNOSTIC, 9, -4.073435366154e-01, inf, 1.2522e-01, 8.1222e-03, \n", + " 2DIAGNOSTIC, 10, -4.098323285580e-01, 2.329702302814e-02, 1.4054e-01, 1.5324e-02, \n", + " 2DIAGNOSTIC, 11, -4.100368022919e-01, 2.154391072690e-02, 1.4629e-01, 5.7540e-03, \n", + " 2DIAGNOSTIC, 12, -4.100507795811e-01, 1.837232336402e-02, 1.5405e-01, 7.7548e-03, \n", + " 2DIAGNOSTIC, 13, -4.101941287518e-01, 1.440118998289e-02, 1.6171e-01, 7.6561e-03, \n", + " 2DIAGNOSTIC, 14, -4.102211892605e-01, 1.019477192312e-02, 1.6789e-01, 6.1860e-03, \n", + " 2DIAGNOSTIC, 15, -4.101466536522e-01, 6.288147997111e-03, 1.7362e-01, 5.7261e-03, \n", + " 2DIAGNOSTIC, 16, -4.101050496101e-01, 3.362666349858e-03, 1.7864e-01, 5.0230e-03, \n", + " 2DIAGNOSTIC, 17, -4.100263714790e-01, 1.330634346232e-03, 1.8367e-01, 5.0299e-03, \n", + " 2DIAGNOSTIC, 18, -4.099549949169e-01, 1.232498325408e-04, 1.8935e-01, 5.6798e-03, \n", + "DIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 2DIAGNOSTIC, 1, -3.132286369801e-01, inf, 2.6857e-01, 7.9222e-02, \n", + " 2DIAGNOSTIC, 2, -3.132618665695e-01, inf, 2.7757e-01, 8.9939e-03, \n", + " 2DIAGNOSTIC, 3, -3.133834898472e-01, inf, 2.8725e-01, 9.6841e-03, \n", + " 2DIAGNOSTIC, 4, -3.134572803974e-01, inf, 2.9732e-01, 1.0073e-02, \n", + " 2DIAGNOSTIC, 5, -3.135836124420e-01, inf, 3.0629e-01, 8.9669e-03, \n", + " 2DIAGNOSTIC, 6, -3.136470317841e-01, inf, 3.1589e-01, 9.6002e-03, \n", + " 2DIAGNOSTIC, 7, -3.138314485550e-01, inf, 3.2618e-01, 1.0286e-02, \n", + " 2DIAGNOSTIC, 8, -3.136978447437e-01, inf, 3.3683e-01, 1.0657e-02, \n", + " 2DIAGNOSTIC, 9, -3.138960897923e-01, inf, 3.4696e-01, 1.0129e-02, \n", + " 2DIAGNOSTIC, 10, -3.138574361801e-01, 1.471677096561e-04, 3.5713e-01, 1.0167e-02, \n", + " 2DIAGNOSTIC, 11, -3.139533102512e-01, 1.262568111997e-04, 3.6676e-01, 9.6328e-03, \n", + " 2DIAGNOSTIC, 12, -3.140722811222e-01, 1.090098739951e-04, 3.7673e-01, 9.9640e-03, \n", + " 2DIAGNOSTIC, 13, -3.141798973083e-01, 1.006781312753e-04, 3.8661e-01, 9.8879e-03, \n", + " 2DIAGNOSTIC, 14, -3.144098818302e-01, 1.040978313540e-04, 3.9576e-01, 9.1438e-03, \n", + " 2DIAGNOSTIC, 15, -3.147285878658e-01, 1.242928847205e-04, 4.0576e-01, 1.0002e-02, \n", + " 2DIAGNOSTIC, 16, -3.145048618317e-01, 1.211132912431e-04, 4.1604e-01, 1.0276e-02, \n", + " 2DIAGNOSTIC, 17, -3.145472109318e-01, 1.203150677611e-04, 4.2700e-01, 1.0967e-02, \n", + " 2DIAGNOSTIC, 18, -3.145489394665e-01, 1.017092508846e-04, 4.3678e-01, 9.7809e-03, \n", + " 2DIAGNOSTIC, 19, -3.146262168884e-01, 8.871840691427e-05, 4.4580e-01, 9.0179e-03, \n", + " 2DIAGNOSTIC, 20, -3.147916793823e-01, 7.438630564138e-05, 4.5698e-01, 1.1182e-02, \n", + " 2DIAGNOSTIC, 21, -3.149661719799e-01, 6.630339339608e-05, 4.6834e-01, 1.1359e-02, \n", + " 2DIAGNOSTIC, 22, -3.149224519730e-01, 5.613908797386e-05, 4.7863e-01, 1.0291e-02, \n", + " 2DIAGNOSTIC, 23, -3.148387372494e-01, 4.265262032277e-05, 4.8879e-01, 1.0156e-02, \n", + " 2DIAGNOSTIC, 24, -3.148630559444e-01, 3.569481850718e-05, 4.9969e-01, 1.0901e-02, \n", + " 2DIAGNOSTIC, 25, -3.148529827595e-01, 3.726454451680e-05, 5.0863e-01, 8.9400e-03, \n", + " 2DIAGNOSTIC, 26, -3.148906826973e-01, 2.871352444345e-05, 5.1761e-01, 8.9810e-03, \n", + " 2DIAGNOSTIC, 27, -3.149789571762e-01, 2.268991374876e-05, 5.2778e-01, 1.0169e-02, \n", + " 2DIAGNOSTIC, 28, -3.150068223476e-01, 1.608521415619e-05, 5.3807e-01, 1.0291e-02, \n", + " 2DIAGNOSTIC, 29, -3.150796890259e-01, 1.312824497290e-05, 5.5219e-01, 1.4114e-02, \n", + " 2DIAGNOSTIC, 30, -3.150897026062e-01, 1.430128395441e-05, 5.6265e-01, 1.0469e-02, \n", + " 2DIAGNOSTIC, 31, -3.150594234467e-01, 1.837359377532e-05, 5.7280e-01, 1.0143e-02, \n", + " 2DIAGNOSTIC, 32, -3.150995373726e-01, 2.052920171991e-05, 5.9040e-01, 1.7605e-02, \n", + " 2DIAGNOSTIC, 33, -3.151014745235e-01, 1.838905336626e-05, 6.0081e-01, 1.0412e-02, \n", + " 2DIAGNOSTIC, 34, -3.150934278965e-01, 1.517354940006e-05, 6.1034e-01, 9.5220e-03, \n", + " 2DIAGNOSTIC, 35, -3.150951564312e-01, 1.060028807842e-05, 6.2262e-01, 1.2281e-02, \n", + " 2DIAGNOSTIC, 36, -3.150955140591e-01, 6.295613275142e-06, 6.3178e-01, 9.1600e-03, \n", + " 2DIAGNOSTIC, 37, -3.150922358036e-01, 3.774448941840e-06, 6.4194e-01, 1.0166e-02, \n", + " 2DIAGNOSTIC, 38, -3.150919675827e-01, 1.705915906314e-06, 6.5374e-01, 1.1801e-02, \n", + " 2DIAGNOSTIC, 39, -3.150787353516e-01, 1.045118210641e-06, 6.6302e-01, 9.2790e-03, \n", + "DIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 2DIAGNOSTIC, 1, -2.526758313179e-01, inf, 7.3463e-01, 7.1602e-02, \n", + " 2DIAGNOSTIC, 2, -2.526561915874e-01, inf, 7.4545e-01, 1.0824e-02, \n", + " 2DIAGNOSTIC, 3, -2.525903284550e-01, inf, 7.5686e-01, 1.1412e-02, \n", + " 2DIAGNOSTIC, 4, -2.525710463524e-01, inf, 7.7637e-01, 1.9505e-02, \n", + " 2DIAGNOSTIC, 5, -2.525512874126e-01, inf, 7.9188e-01, 1.5517e-02, \n", + " 2DIAGNOSTIC, 6, -2.525440454483e-01, inf, 8.0254e-01, 1.0656e-02, \n", + " 2DIAGNOSTIC, 7, -2.525190412998e-01, inf, 8.1274e-01, 1.0196e-02, \n", + " 2DIAGNOSTIC, 8, -2.525074481964e-01, inf, 8.2367e-01, 1.0936e-02, \n", + " 2DIAGNOSTIC, 9, -2.525008320808e-01, inf, 8.3452e-01, 1.0851e-02, \n", + "DIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 2DIAGNOSTIC, 1, -2.124983221292e-01, inf, 1.1096e+00, 2.7510e-01, \n", + " Elapsed time (stage 0): 1.3250e+00\n", + "\n", + "\n", + "Stage 1\n", + " iterations = 40x20x0\n", + " convergence threshold = 1.0000e-07\n", + " convergence window size = 8\n", + " number of levels = 3\n", + " using the Mattes MI metric (number of bins = 32, weight = 1.0000e+00, use gradient filter = 0)\n", + " preprocessing: histogram matching the images\n", + " Shrink factors (level 1 out of 3): [4, 4, 4]\n", + " Shrink factors (level 2 out of 3): [2, 2, 2]\n", + " Shrink factors (level 3 out of 3): [1, 1, 1]\n", + " smoothing sigmas per level: [2, 1, 0]\n", + " Using default NONE metricSamplingStrategy \n", + "\n", + "*** Running SyN registration (varianceForUpdateField = 3.0000e+00, varianceForTotalField = 0.0000e+00) ***\n", + "\n", + "XXDIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 1DIAGNOSTIC, 1, -4.346560835838e-01, inf, 8.1674e-02, 8.1673e-02, \n", + " 1DIAGNOSTIC, 2, -4.400676488876e-01, inf, 1.1524e-01, 3.3566e-02, \n", + " 1DIAGNOSTIC, 3, -4.466428458691e-01, inf, 1.5058e-01, 3.5343e-02, \n", + " 1DIAGNOSTIC, 4, -4.531919360161e-01, inf, 1.8656e-01, 3.5978e-02, \n", + " 1DIAGNOSTIC, 5, -4.592019617558e-01, inf, 2.2411e-01, 3.7546e-02, \n", + " 1DIAGNOSTIC, 6, -4.647512435913e-01, inf, 2.6025e-01, 3.6138e-02, \n", + " 1DIAGNOSTIC, 7, -4.696357250214e-01, inf, 2.9666e-01, 3.6411e-02, \n", + " 1DIAGNOSTIC, 8, -4.745597839355e-01, 7.322176359594e-03, 3.3241e-01, 3.5750e-02, \n", + " 1DIAGNOSTIC, 9, -4.791986942291e-01, 6.199246272445e-03, 3.7222e-01, 3.9812e-02, \n", + " 1DIAGNOSTIC, 10, -4.837881326675e-01, 5.218462087214e-03, 4.0984e-01, 3.7623e-02, \n", + " 1DIAGNOSTIC, 11, -4.880060553551e-01, 4.441852681339e-03, 4.4712e-01, 3.7275e-02, \n", + " 1DIAGNOSTIC, 12, -4.920468330383e-01, 3.843527985737e-03, 4.8449e-01, 3.7376e-02, \n", + " 1DIAGNOSTIC, 13, -4.960613548756e-01, 3.377406857908e-03, 5.2392e-01, 3.9430e-02, \n", + " 1DIAGNOSTIC, 14, -4.997787773609e-01, 2.996241673827e-03, 5.5975e-01, 3.5831e-02, \n", + " 1DIAGNOSTIC, 15, -5.033940672874e-01, 2.662716899067e-03, 5.9672e-01, 3.6964e-02, \n", + " 1DIAGNOSTIC, 16, -5.067696571350e-01, 2.375914482400e-03, 6.3328e-01, 3.6566e-02, \n", + " 1DIAGNOSTIC, 17, -5.099863409996e-01, 2.123554470018e-03, 6.7343e-01, 4.0152e-02, \n", + " 1DIAGNOSTIC, 18, -5.132558345795e-01, 1.914892462082e-03, 7.1166e-01, 3.8229e-02, \n", + " 1DIAGNOSTIC, 19, -5.164546370506e-01, 1.737622893415e-03, 7.5031e-01, 3.8644e-02, \n", + " 1DIAGNOSTIC, 20, -5.197445750237e-01, 1.593724242412e-03, 7.8785e-01, 3.7539e-02, \n", + " 1DIAGNOSTIC, 21, -5.228637456894e-01, 1.478839549236e-03, 8.3590e-01, 4.8051e-02, \n", + " 1DIAGNOSTIC, 22, -5.257505178452e-01, 1.376285450533e-03, 8.7382e-01, 3.7918e-02, \n", + " 1DIAGNOSTIC, 23, -5.285803675652e-01, 1.283859135583e-03, 9.1189e-01, 3.8078e-02, \n", + " 1DIAGNOSTIC, 24, -5.309954285622e-01, 1.184747903608e-03, 9.5008e-01, 3.8184e-02, \n", + " 1DIAGNOSTIC, 25, -5.336643457413e-01, 1.088752876967e-03, 9.9124e-01, 4.1167e-02, \n", + " 1DIAGNOSTIC, 26, -5.357834100723e-01, 9.883682942018e-04, 1.0292e+00, 3.7963e-02, \n", + " 1DIAGNOSTIC, 27, -5.378876328468e-01, 8.902329718694e-04, 1.0694e+00, 4.0157e-02, \n", + " 1DIAGNOSTIC, 28, -5.396262407303e-01, 7.956389454193e-04, 1.1093e+00, 3.9961e-02, \n", + " 1DIAGNOSTIC, 29, -5.413658618927e-01, 7.089403225109e-04, 1.1472e+00, 3.7837e-02, \n", + " 1DIAGNOSTIC, 30, -5.432823300362e-01, 6.362450658344e-04, 1.1839e+00, 3.6762e-02, \n", + " 1DIAGNOSTIC, 31, -5.455060601234e-01, 5.888605955988e-04, 1.2240e+00, 4.0040e-02, \n", + " 1DIAGNOSTIC, 32, -5.477246046066e-01, 5.585526814684e-04, 1.2607e+00, 3.6751e-02, \n", + " 1DIAGNOSTIC, 33, -5.501509904861e-01, 5.552171496674e-04, 1.2985e+00, 3.7765e-02, \n", + " 1DIAGNOSTIC, 34, -5.524703860283e-01, 5.603276076727e-04, 1.3331e+00, 3.4639e-02, \n", + " 1DIAGNOSTIC, 35, -5.545139312744e-01, 5.641062161885e-04, 1.3727e+00, 3.9572e-02, \n", + " 1DIAGNOSTIC, 36, -5.563727021217e-01, 5.531506612897e-04, 1.4082e+00, 3.5533e-02, \n", + " 1DIAGNOSTIC, 37, -5.581617355347e-01, 5.264999927022e-04, 1.4474e+00, 3.9191e-02, \n", + " 1DIAGNOSTIC, 38, -5.596693158150e-01, 4.850412660744e-04, 1.4852e+00, 3.7751e-02, \n", + " 1DIAGNOSTIC, 39, -5.613737106323e-01, 4.430034896359e-04, 1.5234e+00, 3.8243e-02, \n", + " 1DIAGNOSTIC, 40, -5.631178617477e-01, 4.050220304634e-04, 1.5601e+00, 3.6678e-02, \n", + "XXDIAGNOSTIC,Iteration,metricValue,convergenceValue,ITERATION_TIME_INDEX,SINCE_LAST\n", + " 1DIAGNOSTIC, 1, -4.846807122231e-01, inf, 1.8241e+00, 2.6405e-01, \n", + " 1DIAGNOSTIC, 2, -4.857093691826e-01, inf, 2.0126e+00, 1.8844e-01, \n", + " 1DIAGNOSTIC, 3, -4.875206053257e-01, inf, 2.2474e+00, 2.3484e-01, \n", + " 1DIAGNOSTIC, 4, -4.891018271446e-01, inf, 2.4541e+00, 2.0670e-01, \n", + " 1DIAGNOSTIC, 5, -4.905070662498e-01, inf, 2.6681e+00, 2.1398e-01, \n", + " 1DIAGNOSTIC, 6, -4.916913509369e-01, inf, 2.8639e+00, 1.9583e-01, \n", + " 1DIAGNOSTIC, 7, -4.927156567574e-01, inf, 3.0977e+00, 2.3379e-01, \n", + " 1DIAGNOSTIC, 8, -4.936387240887e-01, 1.566889230162e-03, 3.2964e+00, 1.9865e-01, \n", + " 1DIAGNOSTIC, 9, -4.944962263107e-01, 1.289925887249e-03, 3.5481e+00, 2.5176e-01, \n", + " 1DIAGNOSTIC, 10, -4.952964782715e-01, 1.022447715513e-03, 3.7370e+00, 1.8892e-01, \n", + " 1DIAGNOSTIC, 11, -4.960424304008e-01, 8.282995549962e-04, 3.9616e+00, 2.2457e-01, \n", + " 1DIAGNOSTIC, 12, -4.967186450958e-01, 6.852098158561e-04, 4.1599e+00, 1.9830e-01, \n", + " 1DIAGNOSTIC, 13, -4.973587691784e-01, 5.800853250548e-04, 4.3465e+00, 1.8659e-01, \n", + " 1DIAGNOSTIC, 14, -4.979346692562e-01, 4.976075142622e-04, 4.5243e+00, 1.7779e-01, \n", + " 1DIAGNOSTIC, 15, -4.984379410744e-01, 4.280433058739e-04, 4.7435e+00, 2.1926e-01, \n", + " 1DIAGNOSTIC, 16, -4.989303946495e-01, 3.691686433740e-04, 4.9297e+00, 1.8612e-01, \n", + " 1DIAGNOSTIC, 17, -4.993416666985e-01, 3.174705198035e-04, 5.1199e+00, 1.9021e-01, \n", + " 1DIAGNOSTIC, 18, -4.996961057186e-01, 2.715990704019e-04, 5.3151e+00, 1.9521e-01, \n", + " 1DIAGNOSTIC, 19, -5.000337362289e-01, 2.320553903701e-04, 5.5263e+00, 2.1118e-01, \n", + " 1DIAGNOSTIC, 20, -5.003664493561e-01, 1.987953146454e-04, 5.7057e+00, 1.7944e-01, \n", + " Elapsed time (stage 1): 6.15\n", + "\n", + "\n", + "Total elapsed time: 7.494\n" + ] + } + ], + "source": [ + "transformation = ants.registration(\n", + " fixed=template_img_ants,\n", + " moving=raw_img_ants[:,:,:,0], \n", + " type_of_transform='SyN',\n", + " verbose=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bd648001-1989-4402-8ac6-76691206dba0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'warpedmovout': ANTsImage (IAL)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (182, 218, 182)\n", + "\t Spacing : (1.0, 1.0, 1.0)\n", + "\t Origin : (91.0, -91.0, -72.0)\n", + "\t Direction : [ 0. 0. -1. 0. 1. 0. 1. 0. 0.]\n", + ", 'warpedfixout': ANTsImage (RAI)\n", + "\t Pixel Type : float (float32)\n", + "\t Components : 1\n", + "\t Dimensions : (71, 89, 72)\n", + "\t Spacing : (2.0, 2.0, 2.0)\n", + "\t Origin : (67.2627, 113.7728, -60.5885)\n", + "\t Direction : [1. 0. 0. 0. 1. 0. 0. 0. 1.]\n", + ", 'fwdtransforms': ['/tmp/tmplblaew7e1Warp.nii.gz', '/tmp/tmplblaew7e0GenericAffine.mat'], 'invtransforms': ['/tmp/tmplblaew7e0GenericAffine.mat', '/tmp/tmplblaew7e1InverseWarp.nii.gz']}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a8e0950e7b6c4dd9a09afe3108580c24", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=90, description='SLICE', max=181), Output()), _dom_classes=('widget-inte…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(transformation)\n", + "registered_img_ants = transformation['warpedmovout']\n", + "\n", + "explore_3D_array(arr=registered_img_ants.numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "f7aedf63-0404-4f01-9c34-13f47ae353d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(71, 89, 72, 370)\n", + "(182, 218, 182)\n", + "(71, 89, 72)\n" + ] + } + ], + "source": [ + "import nibabel as nib\n", + "img = nib.load('/weka/proj-medarc/shared/bold5000/CSI1_GLMbetas-TYPED-FITHRF-GLMDENOISE-RR_ses-01.nii.gz')\n", + "print(img.shape)\n", + "\n", + "img2 = nib.load('/weka/proj-medarc/shared/bold5000_open_neuro/nsdgeneral_to_MNI.nii.gz')\n", + "print(img2.shape)\n", + "\n", + "mask = nib.load('/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/roi_in_functional_space.nii.gz')\n", + "print(mask.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "b7c0daa7-f7d1-4e0e-814a-5d17f6bb756e", + "metadata": {}, + "outputs": [], + "source": [ + "a = mask.get_fdata()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "1b2b88b6-d80f-49d1-915c-3948ff3522ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19110.963048299607" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "1b429c17-f613-4b6d-8901-1c328e471c38", + "metadata": {}, + "outputs": [ + { + "ename": "Exception", + "evalue": "Transform /weka/proj-medarc/shared/bold5000_open_neuro/ants_output/sub-CSI1_T1w_target-MNI_warp.nii.gz does not exist", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[32], line 25\u001b[0m\n\u001b[1;32m 17\u001b[0m mni_roi \u001b[38;5;241m=\u001b[39m ants\u001b[38;5;241m.\u001b[39mimage_read(mni_roi_path)\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# Apply inverse transforms:\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Note: When going from T1->MNI, you apply [affine, warp].\u001b[39;00m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;66;03m# For MNI->T1, you apply them in reverse order with inversion:\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;66;03m# - Invert the warp\u001b[39;00m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m# - Invert the affine\u001b[39;00m\n\u001b[0;32m---> 25\u001b[0m mni_to_t1_mask \u001b[38;5;241m=\u001b[39m \u001b[43mants\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_transforms\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[43m \u001b[49m\u001b[43mfixed\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mt1_native\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 27\u001b[0m \u001b[43m \u001b[49m\u001b[43mmoving\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmni_roi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[43m \u001b[49m\u001b[43mtransformlist\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mt1_to_mni_warp\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1_to_mni_affine\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[43m \u001b[49m\u001b[43minterpolator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnearestNeighbor\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[43m \u001b[49m\u001b[43minvert_transform\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Invert both warp and affine\u001b[39;49;00m\n\u001b[1;32m 31\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[38;5;66;03m# Save the transformed mask\u001b[39;00m\n\u001b[1;32m 34\u001b[0m mni_to_t1_mask\u001b[38;5;241m.\u001b[39mto_filename(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mroi_in_native_space.nii.gz\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/mei-env/lib/python3.11/site-packages/ants/registration/apply_transforms.py:117\u001b[0m, in \u001b[0;36mapply_transforms\u001b[0;34m(fixed, moving, transformlist, interpolator, imagetype, whichtoinvert, compose, defaultvalue, singleprecision, verbose, **kwargs)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m tl_path \u001b[38;5;129;01min\u001b[39;00m transformlist:\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(tl_path):\n\u001b[0;32m--> 117\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTransform \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m does not exist\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m%\u001b[39m tl_path)\n\u001b[1;32m 119\u001b[0m inpixeltype \u001b[38;5;241m=\u001b[39m fixed\u001b[38;5;241m.\u001b[39mpixeltype\n\u001b[1;32m 120\u001b[0m fixed \u001b[38;5;241m=\u001b[39m fixed\u001b[38;5;241m.\u001b[39mclone(output_pixel_type)\n", + "\u001b[0;31mException\u001b[0m: Transform /weka/proj-medarc/shared/bold5000_open_neuro/ants_output/sub-CSI1_T1w_target-MNI_warp.nii.gz does not exist" + ] + } + ], + "source": [ + "import ants\n", + "\n", + "# Paths to images\n", + "t1_native_path = \"/weka/proj-medarc/shared/bold5000_open_neuro/ds001499-download/derivatives/fmriprep/sub-CSI1/anat/sub-CSI1_T1w_preproc.nii.gz\"\n", + "mni_roi_path = \"/weka/proj-medarc/shared/bold5000_open_neuro/nsdgeneral_to_MNI.nii.gz\"\n", + "func_t1_path = \"/weka/proj-medarc/shared/bold5000_open_neuro/ds001499-download/derivatives/fmriprep/sub-CSI1/ses-01/func/sub-CSI1_ses-01_task-5000scenes_run-01_bold_space-T1w_preproc.nii.gz\"\n", + "\n", + "# Paths to transforms (these are examples; replace with the actual transform files produced by fMRIPrep)\n", + "# Typically, fMRIPrep generates transforms such as:\n", + "# - sub-CSI1_T1w_target-MNI_warp.nii.gz (Nonlinear warp)\n", + "# - sub-CSI1_T1w_target-MNI_affine.txt (Affine transform)\n", + "t1_to_mni_warp = \"/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/sub-CSI1_T1w_target-MNI_warp.nii.gz\"\n", + "t1_to_mni_affine = \"/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/sub-CSI1_T1w_target-MNI_affine.txt\"\n", + "\n", + "# Load the images\n", + "t1_native = ants.image_read(t1_native_path)\n", + "mni_roi = ants.image_read(mni_roi_path)\n", + "\n", + "# Apply inverse transforms:\n", + "# Note: When going from T1->MNI, you apply [affine, warp].\n", + "# For MNI->T1, you apply them in reverse order with inversion:\n", + "# - Invert the warp\n", + "# - Invert the affine\n", + "\n", + "mni_to_t1_mask = ants.apply_transforms(\n", + " fixed=t1_native,\n", + " moving=mni_roi,\n", + " transformlist=[t1_to_mni_warp, t1_to_mni_affine],\n", + " interpolator='nearestNeighbor',\n", + " invert_transform=[True, True] # Invert both warp and affine\n", + ")\n", + "\n", + "# Save the transformed mask\n", + "mni_to_t1_mask.to_filename(\"roi_in_native_space.nii.gz\")\n", + "\n", + "# Now load your functional data (already in T1 space)\n", + "func_img = ants.image_read(func_t1_path)\n", + "\n", + "# Extract voxel values from the functional image using the native-space ROI\n", + "# Create a boolean mask (True where ROI > 0)\n", + "roi_data = (mni_to_t1_mask.numpy() > 0)\n", + "\n", + "# Extract the timeseries data at those voxel locations\n", + "func_data = func_img.numpy() # shape: (x, y, z, time)\n", + "roi_timeseries = func_data[roi_data, :]\n", + "\n", + "# 'roi_timeseries' is now a numpy array of shape (n_voxels_in_roi, time)\n", + "# You can further process this data as needed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "ab2eba85-a452-41cb-ad7f-bee85e54fe76", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the 4D functional image\n", + "img_4d = ants.image_read(\"/weka/proj-medarc/shared/bold5000_open_neuro/ds001499-download/derivatives/fmriprep/sub-CSI1/ses-01/func/sub-CSI1_ses-01_task-5000scenes_run-01_bold_space-T1w_preproc.nii.gz\")\n", + "\n", + "# Extract the first 3D volume (timepoint 0)\n", + "# Convert the antsImage to a numpy array, select the first volume along the 4th dimension\n", + "img_3d_data = img_4d.numpy()[:, :, :, 0]\n", + "\n", + "# Create a new antsImage from the extracted volume,\n", + "# preserving the original spacing, origin, direction of the first 3 dimensions.\n", + "img_3d = ants.from_numpy(img_3d_data, \n", + " spacing=img_4d.spacing[:3], \n", + " origin=img_4d.origin[:3], \n", + " direction=img_4d.direction[:3,:3])\n", + "\n", + "# Save the single 3D volume\n", + "img_3d.to_filename(\"/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/func_ref.nii.gz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "4b269e6a-7594-4e70-9e27-ec91ee6119e1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ants\n", + "import matplotlib.pyplot as plt\n", + "\n", + "func_ref = ants.image_read(\"/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/func_ref.nii.gz\")\n", + "mask = ants.image_read(\"/weka/proj-medarc/shared/bold5000_open_neuro/ants_output/roi_in_functional_space.nii.gz\")\n", + "\n", + "# Display a middle slice in the z-dimension for example\n", + "slice_z = 60\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "ax[0].imshow(func_ref[:,:,slice_z].numpy().T, origin='lower', cmap='gray')\n", + "ax[0].set_title('Functional Reference')\n", + "\n", + "# Overlay the mask\n", + "overlay = mask[:,:,slice_z].numpy().T\n", + "ax[1].imshow(func_ref[:,:,slice_z].numpy().T, origin='lower', cmap='gray')\n", + "ax[1].imshow(overlay, origin='lower', alpha=0.5, cmap='Reds')\n", + "ax[1].set_title('Functional + Mask Overlay')\n", + "\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mei-env", + "language": "python", + "name": "mei-env" + }, + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/enhanced_recon_inference.ipynb b/MindEyeV2/src/enhanced_recon_inference.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..eba6216c79e68c142b1048b1bf057cf8a52b15b3 --- /dev/null +++ b/MindEyeV2/src/enhanced_recon_inference.ipynb @@ -0,0 +1,891 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6b18f6a3-cc4f-437e-9756-c99fc6a5fad4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: cuda\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/mindeye/lib/python3.11/site-packages/accelerate/accelerator.py:457: FutureWarning: Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: dict_keys(['split_batches']). Please pass an `accelerate.DataLoaderConfiguration` instead: \n", + "dataloader_config = DataLoaderConfiguration(split_batches=False)\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder, FrozenCLIPEmbedder, FrozenOpenCLIPEmbedder2\n", + "from generative_models.sgm.models.diffusion import DiffusionEngine\n", + "from generative_models.sgm.util import append_dims\n", + "from omegaconf import OmegaConf\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "from models import *\n", + "\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "device = accelerator.device\n", + "print(\"device:\",device)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "20cdb696-1d6e-4b73-951b-b0cd1dda219a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_375trials_24bs\n", + "--model_name=final_subj01_pretrained_375trials_24bs --subj=1 --mode=imagery\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"final_subj01_pretrained_375trials_24bs\"\n", + " print(\"model_name:\", model_name)\n", + " mode = \"imagery\"\n", + " # global_batch_size and batch_size should already be defined in the above cells\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--model_name={model_name} --subj=1 --mode={mode}\"\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4b31d7c0-f5bd-4a19-a8be-7a3a165d79b6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/18 [00:00 r c', r=resized_recons.shape[0], c=resized_recons.shape[1])\n", + "\n", + "print(model_name)\n", + "print(all_images.shape, rep_all_recons.shape, rep_all_clipvoxels.shape, rep_all_blurryrecons.shape, rep_all_predcaptions.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "24bdd667-0862-4561-b432-9fa7543df863", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n", + "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized embedder #0: FrozenCLIPEmbedder with 123060480 params. Trainable: False\n", + "Initialized embedder #1: FrozenOpenCLIPEmbedder2 with 694659841 params. Trainable: False\n", + "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "Initialized embedder #3: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "Initialized embedder #4: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "Restored from /weka/proj-medarc/shared/mindeyev2_dataset/zavychromaxl_v30.safetensors with 1 missing and 1 unexpected keys\n", + "Missing Keys: ['denoiser.sigmas']\n", + "Unexpected Keys: ['conditioner.embedders.0.transformer.text_model.embeddings.position_ids']\n", + "crossattn torch.Size([1, 77, 2048])\n", + "vector_suffix torch.Size([1, 1536])\n", + "---\n", + "crossattn_uc torch.Size([1, 77, 2048])\n", + "vector_uc torch.Size([1, 2816])\n" + ] + } + ], + "source": [ + "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n", + "config = OmegaConf.to_container(config, resolve=True)\n", + "unclip_params = config[\"model\"][\"params\"]\n", + "sampler_config = unclip_params[\"sampler_config\"]\n", + "sampler_config['params']['num_steps'] = 38\n", + "config = OmegaConf.load(\"generative_models/configs/inference/sd_xl_base.yaml\")\n", + "config = OmegaConf.to_container(config, resolve=True)\n", + "refiner_params = config[\"model\"][\"params\"]\n", + "\n", + "network_config = refiner_params[\"network_config\"]\n", + "denoiser_config = refiner_params[\"denoiser_config\"]\n", + "first_stage_config = refiner_params[\"first_stage_config\"]\n", + "conditioner_config = refiner_params[\"conditioner_config\"]\n", + "scale_factor = refiner_params[\"scale_factor\"]\n", + "disable_first_stage_autocast = refiner_params[\"disable_first_stage_autocast\"]\n", + "\n", + "# base_ckpt_path = '/weka/robin/projects/stable-research/checkpoints/sd_xl_base_1.0.safetensors'\n", + "base_ckpt_path = '/weka/proj-medarc/shared/mindeyev2_dataset/zavychromaxl_v30.safetensors'\n", + "base_engine = DiffusionEngine(network_config=network_config,\n", + " denoiser_config=denoiser_config,\n", + " first_stage_config=first_stage_config,\n", + " conditioner_config=conditioner_config,\n", + " sampler_config=sampler_config, # using the one defined by the unclip\n", + " scale_factor=scale_factor,\n", + " disable_first_stage_autocast=disable_first_stage_autocast,\n", + " ckpt_path=base_ckpt_path)\n", + "base_engine.eval().requires_grad_(False)\n", + "base_engine.to(device)\n", + "\n", + "base_text_embedder1 = FrozenCLIPEmbedder(\n", + " layer=conditioner_config['params']['emb_models'][0]['params']['layer'],\n", + " layer_idx=conditioner_config['params']['emb_models'][0]['params']['layer_idx'],\n", + ")\n", + "base_text_embedder1.to(device)\n", + "\n", + "base_text_embedder2 = FrozenOpenCLIPEmbedder2(\n", + " arch=conditioner_config['params']['emb_models'][1]['params']['arch'],\n", + " version=conditioner_config['params']['emb_models'][1]['params']['version'],\n", + " freeze=conditioner_config['params']['emb_models'][1]['params']['freeze'],\n", + " layer=conditioner_config['params']['emb_models'][1]['params']['layer'],\n", + " always_return_pooled=conditioner_config['params']['emb_models'][1]['params']['always_return_pooled'],\n", + " legacy=conditioner_config['params']['emb_models'][1]['params']['legacy'],\n", + ")\n", + "base_text_embedder2.to(device)\n", + "\n", + "batch={\"txt\": \"\",\n", + " \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n", + " \"crop_coords_top_left\": torch.zeros(1, 2).to(device),\n", + " \"target_size_as_tuple\": torch.ones(1, 2).to(device) * 1024}\n", + "out = base_engine.conditioner(batch)\n", + "crossattn = out[\"crossattn\"].to(device)\n", + "vector_suffix = out[\"vector\"][:,-1536:].to(device)\n", + "print(\"crossattn\", crossattn.shape)\n", + "print(\"vector_suffix\", vector_suffix.shape)\n", + "print(\"---\")\n", + "\n", + "batch_uc={\"txt\": \"painting, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, deformed, ugly, blurry, bad anatomy, bad proportions, extra limbs, cloned face, skinny, glitchy, double torso, extra arms, extra hands, mangled fingers, missing lips, ugly face, distorted face, extra legs, anime\",\n", + " \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n", + " \"crop_coords_top_left\": torch.zeros(1, 2).to(device),\n", + " \"target_size_as_tuple\": torch.ones(1, 2).to(device) * 1024}\n", + "out = base_engine.conditioner(batch_uc)\n", + "crossattn_uc = out[\"crossattn\"].to(device)\n", + "vector_uc = out[\"vector\"].to(device)\n", + "print(\"crossattn_uc\", crossattn_uc.shape)\n", + "print(\"vector_uc\", vector_uc.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "07f437d1-9b8e-4b13-85ad-d45062a5ce09", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if utils.is_interactive(): plotting=False\n", + "plotting=False\n", + "num_samples = 1 # PS: I tried increasing this to 16 and picking highest cosine similarity like we did in MindEye1, it didnt seem to increase eval performance!\n", + "img2img_timepoint = 13 # 9 # higher number means more reliance on prompt, less reliance on matching the conditioning image\n", + "base_engine.sampler.guider.scale = 5 # 5 # cfg\n", + "def denoiser(x, sigma, c): return base_engine.denoiser(base_engine.model, x, sigma, c)\n", + "\n", + "if plotting or num_samples>1:\n", + " clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + " )\n", + " clip_img_embedder.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "939e1cbb-5836-48c2-87d8-3e493e950011", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a3e32a1951204ca79d0ab0117da33406", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/18 [00:001:\n", + " clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + " )\n", + " clip_img_embedder.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "939e1cbb-5836-48c2-87d8-3e493e950011", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/utils/checkpoint.py:429: UserWarning: torch.utils.checkpoint: please pass in use_reentrant=True or use_reentrant=False explicitly. The default value of use_reentrant will be updated to be False in the future. To maintain current behavior, pass use_reentrant=True. It is recommended that you use use_reentrant=False. Refer to docs for more details on the differences between the two variants.\n", + " warnings.warn(\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/utils/checkpoint.py:61: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "samples torch.Size([1, 3, 768, 768])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CHOSEN ABOVE\n", + "upsampled pixcorr: tensor(0.1999)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:05 75\u001b[0m \u001b[43merr\u001b[49m \u001b[38;5;66;03m# dont want to do entire for loop with plotting=True\u001b[39;00m\n\u001b[1;32m 77\u001b[0m samples \u001b[38;5;241m=\u001b[39m samples[which_sample]\n\u001b[1;32m 79\u001b[0m samples \u001b[38;5;241m=\u001b[39m samples\u001b[38;5;241m.\u001b[39mcpu()[\u001b[38;5;28;01mNone\u001b[39;00m]\n", + "\u001b[0;31mNameError\u001b[0m: name 'err' is not defined" + ] + } + ], + "source": [ + "all_enhancedrecons = None\n", + "for img_idx in tqdm(range(len(all_recons))):\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16), base_engine.ema_scope():\n", + " base_engine.sampler.num_steps = 25\n", + " \n", + " image = all_recons[[img_idx]]\n", + " \n", + " if plotting:\n", + " print(\"blur pixcorr:\",utils.pixcorr(all_blurryrecons[[img_idx]].float(), all_images[[img_idx]].float()))\n", + " print(\"blur cossim:\",nn.functional.cosine_similarity(clip_img_embedder(utils.resize(all_blurryrecons[[img_idx]].float(),256).to(device)).flatten(1), \n", + " clip_img_embedder(utils.resize(all_images[[img_idx]].float(),224).to(device)).flatten(1)))\n", + "\n", + " print(\"recon pixcorr:\",utils.pixcorr(image,all_images[[img_idx]].float()))\n", + " print(\"recon cossim:\",nn.functional.cosine_similarity(clip_img_embedder(utils.resize(image,224).to(device)).flatten(1), \n", + " clip_img_embedder(utils.resize(all_images[[img_idx]].float(),224).to(device)).flatten(1)))\n", + " \n", + " image = image.to(device)\n", + " prompt = all_predcaptions[[img_idx]][0]\n", + " # prompt = \"\"\n", + " if plotting: \n", + " print(\"prompt:\",prompt)\n", + " plt.imshow(transforms.ToPILImage()(all_blurryrecons[img_idx].float()))\n", + " plt.show()\n", + " plt.imshow(transforms.ToPILImage()(all_recons[img_idx].float()))\n", + " plt.show()\n", + " plt.imshow(transforms.ToPILImage()(image[0]))\n", + " plt.show()\n", + "\n", + " # z = torch.randn(num_samples,4,96,96).to(device)\n", + " assert image.shape[-1]==768\n", + " z = base_engine.encode_first_stage(image*2-1).repeat(num_samples,1,1,1)\n", + "\n", + " openai_clip_text = base_text_embedder1(prompt)\n", + " clip_text_tokenized, clip_text_emb = base_text_embedder2(prompt)\n", + " clip_text_emb = torch.hstack((clip_text_emb, vector_suffix))\n", + " clip_text_tokenized = torch.cat((openai_clip_text, clip_text_tokenized),dim=-1)\n", + " c = {\"crossattn\": clip_text_tokenized.repeat(num_samples,1,1), \"vector\": clip_text_emb.repeat(num_samples,1)}\n", + " uc = {\"crossattn\": crossattn_uc.repeat(num_samples,1,1), \"vector\": vector_uc.repeat(num_samples,1)}\n", + "\n", + " noise = torch.randn_like(z)\n", + " sigmas = base_engine.sampler.discretization(base_engine.sampler.num_steps).to(device)\n", + " init_z = (z + noise * append_dims(sigmas[-img2img_timepoint], z.ndim)) / torch.sqrt(1.0 + sigmas[0] ** 2.0)\n", + " sigmas = sigmas[-img2img_timepoint:].repeat(num_samples,1)\n", + "\n", + " base_engine.sampler.num_steps = sigmas.shape[-1] - 1\n", + " noised_z, _, _, _, c, uc = base_engine.sampler.prepare_sampling_loop(init_z, cond=c, uc=uc, \n", + " num_steps=base_engine.sampler.num_steps)\n", + " for timestep in range(base_engine.sampler.num_steps):\n", + " noised_z = base_engine.sampler.sampler_step(sigmas[:,timestep],\n", + " sigmas[:,timestep+1],\n", + " denoiser, noised_z, cond=c, uc=uc, gamma=0)\n", + " samples_z_base = noised_z\n", + " samples_x = base_engine.decode_first_stage(samples_z_base)\n", + " samples = torch.clamp((samples_x + 1.0) / 2.0, min=0.0, max=1.0)\n", + "\n", + " # find best sample\n", + " if plotting==False and num_samples==1:\n", + " samples = samples[0]\n", + " else:\n", + " sample_cossim = nn.functional.cosine_similarity(clip_img_embedder(utils.resize(samples,224).to(device)).flatten(1), \n", + " clip_img_embedder(utils.resize(all_images[[img_idx]].float(),224).to(device)).flatten(1))\n", + " which_sample = torch.argmax(sample_cossim)\n", + " best_cossim = torch.max(sample_cossim)\n", + "\n", + " if plotting:\n", + " print(\"samples\", samples.shape)\n", + " for n in range(num_samples):\n", + " recon = transforms.ToPILImage()(samples[n])\n", + " plt.imshow(recon)\n", + " plt.show()\n", + " if (n==which_sample).item(): print(\"CHOSEN ABOVE\")\n", + " print(\"upsampled pixcorr:\",utils.pixcorr(samples[[n]].cpu(),all_images[[img_idx]].float()))\n", + " print(\"upsampled cossim:\",nn.functional.cosine_similarity(clip_img_embedder(utils.resize(samples[[n]],224).to(device)).flatten(1), \n", + " clip_img_embedder(utils.resize(all_images[[img_idx]].float(),224).to(device)).flatten(1)))\n", + " err # dont want to do entire for loop with plotting=True\n", + "\n", + " samples = samples[which_sample]\n", + "\n", + " samples = samples.cpu()[None]\n", + " if all_enhancedrecons is None:\n", + " all_enhancedrecons = samples\n", + " else:\n", + " all_enhancedrecons = torch.vstack((all_enhancedrecons, samples))\n", + " \n", + "all_enhancedrecons = transforms.Resize((256,256))(all_enhancedrecons).float()\n", + "print(\"all_enhancedrecons\", all_enhancedrecons.shape)\n", + "torch.save(all_enhancedrecons,f\"evals/{model_name}/{model_name}_all_enhancedrecons.pt\")\n", + "print(f\"saved evals/{model_name}/{model_name}_all_enhancedrecons.pt\")\n", + "\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mindeye", + "language": "python", + "name": "mindeye" + }, + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/final_evaluations.ipynb b/MindEyeV2/src/final_evaluations.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c613d4ebc3480f2188b20fb603e5a268ddf70ae0 --- /dev/null +++ b/MindEyeV2/src/final_evaluations.ipynb @@ -0,0 +1,1575 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7d5f265e-407a-40bd-92fb-a652091fd7ea", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: cuda\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "from sentence_transformers import SentenceTransformer, util\n", + "from transformers import CLIPModel, AutoTokenizer, AutoProcessor\n", + "import evaluate\n", + "import pandas as pd\n", + "\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder\n", + "from models import GNet8_Encoder\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "device = accelerator.device\n", + "print(\"device:\",device)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1ffb659a-8154-4536-ab27-2d976da1bf4e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_40sess_24bs\n", + "--model_name=final_subj01_pretrained_40sess_24bs --subj=1 --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --all_recons_path=evals/final_subj01_pretrained_40sess_24bs/final_subj01_pretrained_40sess_24bs_all_enhancedrecons.pt\n", + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"final_subj01_pretrained_40sess_24bs\"\n", + " all_recons_path = f\"evals/{model_name}/{model_name}_all_enhancedrecons.pt\"\n", + " subj = 1\n", + " \n", + " data_path = \"/weka/proj-medarc/shared/mindeyev2_dataset\"\n", + " cache_dir = \"/weka/proj-medarc/shared/mindeyev2_dataset\"\n", + " \n", + " print(\"model_name:\", model_name)\n", + "\n", + " jupyter_args = f\"--model_name={model_name} --subj={subj} --data_path={data_path} --cache_dir={cache_dir} --all_recons_path={all_recons_path}\"\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb8120cd-f226-4e2c-a6c5-3cd8ef6e9bc8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--all_recons_path\", type=str,\n", + " help=\"Path to where all_recons.pt is stored\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Evaluate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)" + ] + }, + { + "cell_type": "markdown", + "id": "95d66b33-b327-4895-a861-ecc6ccc51296", + "metadata": { + "tags": [] + }, + "source": [ + "# Evals" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "997f9672-b74d-4dcf-b4d7-a593fdce9cc5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Load ground truths, you can find these files on huggingface: https://huggingface.co/datasets/pscotti/mindeyev2/tree/main/evals\n", + "all_images = torch.load(f\"evals/all_images.pt\")\n", + "all_captions = torch.load(f\"evals/all_captions.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "be66f9c9-f25a-48d9-9e9a-272ab33d20ed", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all_recons_path: evals/final_subj01_pretrained_40sess_24bs/final_subj01_pretrained_40sess_24bs_all_enhancedrecons.pt\n", + "final_subj01_pretrained_40sess_24bs_all_recons\n", + "torch.Size([1000, 3, 224, 224]) torch.Size([1000, 3, 512, 512])\n" + ] + } + ], + "source": [ + "print(\"all_recons_path:\", all_recons_path)\n", + "all_recons = torch.load(all_recons_path)\n", + "\n", + "# Residual submodule\n", + "all_clipvoxels = torch.load(f\"evals/{model_name}/{model_name}_all_clipvoxels.pt\")\n", + "# Low-level submodule\n", + "all_blurryrecons = torch.load(f\"evals/{model_name}/{model_name}_all_blurryrecons.pt\")\n", + "# GIT predicted captions\n", + "all_predcaptions = torch.load(f\"evals/{model_name}/{model_name}_all_predcaptions.pt\")\n", + "\n", + "# model name\n", + "model_name_plus_suffix = f\"{model_name}_all_recons\"\n", + "print(model_name_plus_suffix)\n", + "print(all_images.shape, all_recons.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80e783a0-6d8f-4116-9fe7-b3dac7e354c2", + "metadata": {}, + "outputs": [], + "source": [ + "# # Create full grid of recon comparisons \n", + "# from PIL import Image\n", + "\n", + "# imsize = 150\n", + "# if all_images.shape[-1] != imsize:\n", + "# all_images = transforms.Resize((imsize,imsize))(all_images).float()\n", + "# if all_recons.shape[-1] != imsize:\n", + "# all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n", + "\n", + "# num_images = all_recons.shape[0]\n", + "# num_rows = (2 * num_images + 9) // 10\n", + "\n", + "# # Interleave tensors\n", + "# merged = torch.stack([val for pair in zip(all_images, all_recons) for val in pair], dim=0)\n", + "\n", + "# # Calculate grid size\n", + "# grid = torch.zeros((num_rows * 10, 3, all_recons.shape[-1], all_recons.shape[-1]))\n", + "\n", + "# # Populate the grid\n", + "# grid[:2*num_images] = merged\n", + "# grid_images = [transforms.functional.to_pil_image(grid[i]) for i in range(num_rows * 10)]\n", + "\n", + "# # Create the grid image\n", + "# grid_image = Image.new('RGB', (all_recons.shape[-1]*10, all_recons.shape[-1] * num_rows)) # 10 images wide\n", + "\n", + "# # Paste images into the grid\n", + "# for i, img in enumerate(grid_images):\n", + "# grid_image.paste(img, (all_recons.shape[-1] * (i % 10), all_recons.shape[-1] * (i // 10)))\n", + "\n", + "# grid_image.save(f\"{model_name_plus_suffix[:-3]}_1000recons.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f42009e9-f910-4f02-8db6-d46778aa6595", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "imsize = 256\n", + "if all_images.shape[-1] != imsize:\n", + " all_images = transforms.Resize((imsize,imsize))(all_images).float()\n", + "if all_recons.shape[-1] != imsize:\n", + " all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n", + "if all_blurryrecons.shape[-1] != imsize:\n", + " all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float()\n", + " \n", + "if \"enhanced\" in model_name_plus_suffix:\n", + " print(\"weighted averaging to improve low-level evals\")\n", + " all_recons = all_recons*.75 + all_blurryrecons*.25" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "434b33b5-c799-4054-889c-ac74663d31ac", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 2 / 117 / 231 / 164 / 619 / 791\n", + "import textwrap\n", + "def wrap_title(title, wrap_width):\n", + " return \"\\n\".join(textwrap.wrap(title, wrap_width))\n", + "\n", + "fig, axes = plt.subplots(3, 4, figsize=(10, 8))\n", + "jj=-1; kk=0;\n", + "for j in np.array([2,165,119,619,231,791]):\n", + " jj+=1\n", + " # print(kk,jj)\n", + " axes[kk][jj].imshow(utils.torch_to_Image(all_images[j]))\n", + " axes[kk][jj].axis('off')\n", + " axes[kk][jj].set_title(wrap_title(str(all_captions[[j]]),wrap_width=30), fontsize=8)\n", + " jj+=1\n", + " axes[kk][jj].imshow(utils.torch_to_Image(all_recons[j]))\n", + " axes[kk][jj].axis('off')\n", + " axes[kk][jj].set_title(wrap_title(str(all_predcaptions[[j]]),wrap_width=30), fontsize=8)\n", + " if jj==3: \n", + " kk+=1; jj=-1" + ] + }, + { + "cell_type": "markdown", + "id": "5b4deb53-4d85-4292-92c5-bb59077523cf", + "metadata": {}, + "source": [ + "# Retrieval eval" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4f862220-1df3-49b0-a36c-0aa2f168315d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Load embedding model\n", + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + ")\n", + "clip_img_embedder.to(device)\n", + "\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1664" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2e49d57a-9b65-490c-a1e0-61bd05682171", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 3%|█▍ | 1/30 [00:01<00:44, 1.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loop 0: [1.] [1.]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████| 30/30 [00:28<00:00, 1.06it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fwd percent_correct: 0.9996 95% CI: [0.9992,1.0000]\n", + "bwd percent_correct: 0.9987 95% CI: [0.9981,0.9993]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from scipy import stats\n", + "percent_correct_fwds, percent_correct_bwds = [], []\n", + "percent_correct_fwd, percent_correct_bwd = None, None\n", + "\n", + "with torch.cuda.amp.autocast(dtype=torch.float16):\n", + " for test_i, loop in enumerate(tqdm(range(30))):\n", + " random_samps = np.random.choice(np.arange(len(all_images)), size=300, replace=False)\n", + " emb = clip_img_embedder(all_images[random_samps].to(device)).float() # CLIP-Image\n", + "\n", + " emb_ = all_clipvoxels[random_samps].to(device).float() # CLIP-Brain\n", + "\n", + " # flatten if necessary\n", + " emb = emb.reshape(len(emb),-1)\n", + " emb_ = emb_.reshape(len(emb_),-1)\n", + "\n", + " # l2norm \n", + " emb = nn.functional.normalize(emb,dim=-1)\n", + " emb_ = nn.functional.normalize(emb_,dim=-1)\n", + "\n", + " labels = torch.arange(len(emb)).to(device)\n", + " bwd_sim = utils.batchwise_cosine_similarity(emb,emb_) # clip, brain\n", + " fwd_sim = utils.batchwise_cosine_similarity(emb_,emb) # brain, clip\n", + "\n", + " assert len(bwd_sim) == 300\n", + "\n", + " percent_correct_fwds = np.append(percent_correct_fwds, utils.topk(fwd_sim, labels,k=1).item())\n", + " percent_correct_bwds = np.append(percent_correct_bwds, utils.topk(bwd_sim, labels,k=1).item())\n", + "\n", + " if test_i==0:\n", + " print(\"Loop 0:\",percent_correct_fwds, percent_correct_bwds)\n", + " \n", + "percent_correct_fwd = np.mean(percent_correct_fwds)\n", + "fwd_sd = np.std(percent_correct_fwds) / np.sqrt(len(percent_correct_fwds))\n", + "fwd_ci = stats.norm.interval(0.95, loc=percent_correct_fwd, scale=fwd_sd)\n", + "\n", + "percent_correct_bwd = np.mean(percent_correct_bwds)\n", + "bwd_sd = np.std(percent_correct_bwds) / np.sqrt(len(percent_correct_bwds))\n", + "bwd_ci = stats.norm.interval(0.95, loc=percent_correct_bwd, scale=bwd_sd)\n", + "\n", + "print(f\"fwd percent_correct: {percent_correct_fwd:.4f} 95% CI: [{fwd_ci[0]:.4f},{fwd_ci[1]:.4f}]\")\n", + "print(f\"bwd percent_correct: {percent_correct_bwd:.4f} 95% CI: [{bwd_ci[0]:.4f},{bwd_ci[1]:.4f}]\")\n", + "\n", + "fwd_sim = np.array(fwd_sim.cpu())\n", + "bwd_sim = np.array(bwd_sim.cpu())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "70c4a5df-ea7c-44bd-879a-dc97ba05b524", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Given Brain embedding, find correct Image embedding\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Given Brain embedding, find correct Image embedding\")\n", + "fig, ax = plt.subplots(nrows=4, ncols=6, figsize=(11,12))\n", + "for trial in range(4):\n", + " ax[trial, 0].imshow(utils.torch_to_Image(all_images[random_samps][trial]))\n", + " ax[trial, 0].set_title(\"original\\nimage\")\n", + " ax[trial, 0].axis(\"off\")\n", + " for attempt in range(5):\n", + " which = np.flip(np.argsort(fwd_sim[trial]))[attempt]\n", + " ax[trial, attempt+1].imshow(utils.torch_to_Image(all_images[random_samps][which]))\n", + " ax[trial, attempt+1].set_title(f\"Top {attempt+1}\")\n", + " ax[trial, attempt+1].axis(\"off\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0a26e124-2444-434d-a399-d03c2c90cc08", + "metadata": {}, + "source": [ + "## 2-way identification" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3e1778ff-5d6a-4087-b59f-0f44b9e0eada", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from torchvision.models.feature_extraction import create_feature_extractor, get_graph_node_names\n", + "\n", + "@torch.no_grad()\n", + "def two_way_identification(all_recons, all_images, model, preprocess, feature_layer=None, return_avg=True):\n", + " preds = model(torch.stack([preprocess(recon) for recon in all_recons], dim=0).to(device))\n", + " reals = model(torch.stack([preprocess(indiv) for indiv in all_images], dim=0).to(device))\n", + " if feature_layer is None:\n", + " preds = preds.float().flatten(1).cpu().numpy()\n", + " reals = reals.float().flatten(1).cpu().numpy()\n", + " else:\n", + " preds = preds[feature_layer].float().flatten(1).cpu().numpy()\n", + " reals = reals[feature_layer].float().flatten(1).cpu().numpy()\n", + "\n", + " r = np.corrcoef(reals, preds)\n", + " r = r[:len(all_images), len(all_images):]\n", + " congruents = np.diag(r)\n", + "\n", + " success = r < congruents\n", + " success_cnt = np.sum(success, 0)\n", + "\n", + " if return_avg:\n", + " perf = np.mean(success_cnt) / (len(all_images)-1)\n", + " return perf\n", + " else:\n", + " return success_cnt, len(all_images)-1" + ] + }, + { + "cell_type": "markdown", + "id": "df6be966-52ef-4cf6-8078-8d2d9617564b", + "metadata": {}, + "source": [ + "## PixCorr" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2e17ea38-a254-4e90-a910-711734fdd8eb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1000, 541875])\n", + "torch.Size([1000, 541875])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████| 1000/1000 [00:02<00:00, 369.44it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.33277449813082755\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "\n", + "# Flatten images while keeping the batch dimension\n", + "all_images_flattened = preprocess(all_images).reshape(len(all_images), -1).cpu()\n", + "all_recons_flattened = preprocess(all_recons).view(len(all_recons), -1).cpu()\n", + "\n", + "print(all_images_flattened.shape)\n", + "print(all_recons_flattened.shape)\n", + "\n", + "corrsum = 0\n", + "for i in tqdm(range(len(all_images))):\n", + " corrsum += np.corrcoef(all_images_flattened[i], all_recons_flattened[i])[0][1]\n", + "corrmean = corrsum / len(all_images)\n", + "\n", + "pixcorr = corrmean\n", + "print(pixcorr)" + ] + }, + { + "cell_type": "markdown", + "id": "7a556d5b-33a2-44aa-b48d-4b168316bbdd", + "metadata": { + "tags": [] + }, + "source": [ + "## SSIM" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2326fc4c-1248-4d0f-9176-218c6460f285", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "converted, now calculating ssim...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████| 1000/1000 [00:08<00:00, 117.19it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.395366410354444\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# see https://github.com/zijin-gu/meshconv-decoding/issues/3\n", + "from skimage.color import rgb2gray\n", + "from skimage.metrics import structural_similarity as ssim\n", + "\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), \n", + "])\n", + "\n", + "# convert image to grayscale with rgb2grey\n", + "img_gray = rgb2gray(preprocess(all_images).permute((0,2,3,1)).cpu())\n", + "recon_gray = rgb2gray(preprocess(all_recons).permute((0,2,3,1)).cpu())\n", + "print(\"converted, now calculating ssim...\")\n", + "\n", + "ssim_score=[]\n", + "for im,rec in tqdm(zip(img_gray,recon_gray),total=len(all_images)):\n", + " ssim_score.append(ssim(rec, im, multichannel=True, gaussian_weights=True, sigma=1.5, use_sample_covariance=False, data_range=1.0))\n", + "\n", + "ssim = np.mean(ssim_score)\n", + "print(ssim)" + ] + }, + { + "cell_type": "markdown", + "id": "35138520-ec00-48a6-90dc-249a32a783d2", + "metadata": {}, + "source": [ + "## AlexNet" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3b45cc6c-ab80-43e2-b446-c8fcb4fc54e4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/overrides.py:110: UserWarning: 'has_cuda' is deprecated, please use 'torch.backends.cuda.is_built()'\n", + " torch.has_cuda,\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/overrides.py:111: UserWarning: 'has_cudnn' is deprecated, please use 'torch.backends.cudnn.is_available()'\n", + " torch.has_cudnn,\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/overrides.py:117: UserWarning: 'has_mps' is deprecated, please use 'torch.backends.mps.is_built()'\n", + " torch.has_mps,\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torch/overrides.py:118: UserWarning: 'has_mkldnn' is deprecated, please use 'torch.backends.mkldnn.is_available()'\n", + " torch.has_mkldnn,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "---early, AlexNet(2)---\n", + "2-way Percent Correct: 0.9791\n", + "\n", + "---mid, AlexNet(5)---\n", + "2-way Percent Correct: 0.9911\n" + ] + } + ], + "source": [ + "from torchvision.models import alexnet, AlexNet_Weights\n", + "alex_weights = AlexNet_Weights.IMAGENET1K_V1\n", + "\n", + "alex_model = create_feature_extractor(alexnet(weights=alex_weights), return_nodes=['features.4','features.11']).to(device)\n", + "alex_model.eval().requires_grad_(False)\n", + "\n", + "# see alex_weights.transforms()\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(256, interpolation=transforms.InterpolationMode.BILINEAR),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "layer = 'early, AlexNet(2)'\n", + "print(f\"\\n---{layer}---\")\n", + "all_per_correct = two_way_identification(all_recons.to(device).float(), all_images, \n", + " alex_model, preprocess, 'features.4')\n", + "alexnet2 = np.mean(all_per_correct)\n", + "print(f\"2-way Percent Correct: {alexnet2:.4f}\")\n", + "\n", + "layer = 'mid, AlexNet(5)'\n", + "print(f\"\\n---{layer}---\")\n", + "all_per_correct = two_way_identification(all_recons.to(device).float(), all_images, \n", + " alex_model, preprocess, 'features.11')\n", + "alexnet5 = np.mean(all_per_correct)\n", + "print(f\"2-way Percent Correct: {alexnet5:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c296bab2-d106-469e-b997-b32d21a2cf01", + "metadata": {}, + "source": [ + "## InceptionV3" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5a9c1b2b-af2a-476d-a1ac-32ee915ac2ec", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torchvision/models/feature_extraction.py:174: UserWarning: NOTE: The nodes obtained by tracing the model in eval mode are a subsequence of those obtained in train mode. When choosing nodes for feature extraction, you may need to specify output nodes for train and eval mode separately.\n", + " warnings.warn(msg + suggestion_msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2-way Percent Correct: 0.9600\n" + ] + } + ], + "source": [ + "from torchvision.models import inception_v3, Inception_V3_Weights\n", + "weights = Inception_V3_Weights.DEFAULT\n", + "inception_model = create_feature_extractor(inception_v3(weights=weights), \n", + " return_nodes=['avgpool']).to(device)\n", + "inception_model.eval().requires_grad_(False)\n", + "\n", + "# see weights.transforms()\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(342, interpolation=transforms.InterpolationMode.BILINEAR),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "all_per_correct = two_way_identification(all_recons, all_images,\n", + " inception_model, preprocess, 'avgpool')\n", + " \n", + "inception = np.mean(all_per_correct)\n", + "print(f\"2-way Percent Correct: {inception:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d7a25f7f-8298-4413-b512-8a1173413e07", + "metadata": {}, + "source": [ + "## CLIP" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6afbf7ce-8793-4988-a328-a632acd88aa9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2-way Percent Correct: 0.9369\n" + ] + } + ], + "source": [ + "import clip\n", + "clip_model, preprocess = clip.load(\"ViT-L/14\", device=device)\n", + "\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n", + " transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],\n", + " std=[0.26862954, 0.26130258, 0.27577711]),\n", + "])\n", + "\n", + "all_per_correct = two_way_identification(all_recons, all_images,\n", + " clip_model.encode_image, preprocess, None) # final layer\n", + "clip_ = np.mean(all_per_correct)\n", + "print(f\"2-way Percent Correct: {clip_:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e4fed9f8-ef1a-4c6d-a83f-2a934b6e87fd", + "metadata": {}, + "source": [ + "## Efficient Net" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "14143c0f-1b32-43ef-98d8-8ed458df4551", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance: 0.6074689899741206\n" + ] + } + ], + "source": [ + "import scipy as sp\n", + "from torchvision.models import efficientnet_b1, EfficientNet_B1_Weights\n", + "weights = EfficientNet_B1_Weights.DEFAULT\n", + "eff_model = create_feature_extractor(efficientnet_b1(weights=weights), \n", + " return_nodes=['avgpool'])\n", + "eff_model.eval().requires_grad_(False)\n", + "\n", + "# see weights.transforms()\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(255, interpolation=transforms.InterpolationMode.BILINEAR),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "gt = eff_model(preprocess(all_images))['avgpool']\n", + "gt = gt.reshape(len(gt),-1).cpu().numpy()\n", + "fake = eff_model(preprocess(all_recons))['avgpool']\n", + "fake = fake.reshape(len(fake),-1).cpu().numpy()\n", + "\n", + "effnet = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))]).mean()\n", + "print(\"Distance:\",effnet)" + ] + }, + { + "cell_type": "markdown", + "id": "405f669d-cab7-4c75-90cd-651283f65a9e", + "metadata": {}, + "source": [ + "## SwAV" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4c60b0c4-79fe-4cff-95e9-99733c821e67", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /admin/home-paulscotti/.cache/torch/hub/facebookresearch_swav_main\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "/admin/home-paulscotti/mindeye/lib/python3.11/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n", + " warnings.warn(msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance: 0.336268463999033\n" + ] + } + ], + "source": [ + "swav_model = torch.hub.load('facebookresearch/swav:main', 'resnet50')\n", + "swav_model = create_feature_extractor(swav_model, \n", + " return_nodes=['avgpool'])\n", + "swav_model.eval().requires_grad_(False)\n", + "\n", + "preprocess = transforms.Compose([\n", + " transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225]),\n", + "])\n", + "\n", + "gt = swav_model(preprocess(all_images))['avgpool']\n", + "gt = gt.reshape(len(gt),-1).cpu().numpy()\n", + "fake = swav_model(preprocess(all_recons))['avgpool']\n", + "fake = fake.reshape(len(fake),-1).cpu().numpy()\n", + "\n", + "swav = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))]).mean()\n", + "print(\"Distance:\",swav)" + ] + }, + { + "cell_type": "markdown", + "id": "6f6f644d-5e4e-46ec-890c-f703b62f0c3b", + "metadata": {}, + "source": [ + "# Brain Correlation\n", + "### Load brain data, brain masks, image lists" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "36c14558-fb89-426d-af2f-1f555f8025d2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num_voxels for subj01: 15724\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar\n", + "Loaded test dl for subj1!\n", + "\n" + ] + } + ], + "source": [ + "# Load brain data as ground truth\n", + "def my_split_by_node(urls): return urls\n", + "\n", + "voxels = {}\n", + "# Load hdf5 data for betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}_fp32_renorm.hdf5', 'r')\n", + "betas = f['betas'][:]\n", + "betas = torch.Tensor(betas).to(\"cpu\")\n", + "f.close()\n", + "num_voxels = betas[0].shape[-1]\n", + "voxels[f'subj0{subj}'] = betas\n", + "print(f\"num_voxels for subj0{subj}: {num_voxels}\")\n", + "\n", + "if subj==3:\n", + " num_test=2371\n", + "elif subj==4:\n", + " num_test=2188\n", + "elif subj==6:\n", + " num_test=2371\n", + "elif subj==8:\n", + " num_test=2188\n", + "else:\n", + " num_test=3000\n", + "test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\n", + " \n", + "print(test_url)\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\n", + "print(f\"Loaded test dl for subj{subj}!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "f5c1ce7a-f4b7-4d8a-88ae-5db5b2f2dd34", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3000 3000 1000\n" + ] + } + ], + "source": [ + "# Prep test voxels and indices of test images\n", + "test_images_idx = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_voxels = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()]\n", + " test_images_idx = np.append(test_images_idx, behav[:,0,0].cpu().numpy())\n", + "test_images_idx = test_images_idx.astype(int)\n", + "\n", + "assert (test_i+1) * num_test == len(test_voxels) == len(test_images_idx)\n", + "print(test_i, len(test_voxels), len(test_images_idx), len(np.unique(test_images_idx)))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c8df5ebf-014d-46bb-9fb4-c0577e544e49", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Load brain region masks\n", + "brain_region_masks = {}\n", + "with h5py.File(\"brain_region_masks.hdf5\", \"r\") as file:\n", + " # Iterate over each subject\n", + " for subject in file.keys():\n", + " subject_group = file[subject]\n", + " # Load the masks data for each subject\n", + " subject_masks = {\"nsd_general\" : subject_group[\"nsd_general\"][:],\n", + " \"V1\" : subject_group[\"V1\"][:], \n", + " \"V2\" : subject_group[\"V2\"][:], \n", + " \"V3\" : subject_group[\"V3\"][:], \n", + " \"V4\" : subject_group[\"V4\"][:],\n", + " \"higher_vis\" : subject_group[\"higher_vis\"][:]}\n", + " brain_region_masks[subject] = subject_masks\n", + "subject_masks = brain_region_masks[f\"subj0{subj}\"]\n", + "\n", + "# Average voxels of test set across trial repetitions for brain correlation scores\n", + "test_voxels_averaged = torch.zeros((len(np.unique(test_images_idx)),num_voxels))\n", + "# i = 0\n", + "uniq_imgs = np.unique(test_images_idx)\n", + "for i, uniq_img in enumerate(uniq_imgs):\n", + " locs = np.where(test_images_idx==uniq_img)[0]\n", + " if len(locs)==1:\n", + " locs = locs.repeat(3)\n", + " elif len(locs)==2:\n", + " locs = locs.repeat(2)[:3]\n", + " assert len(locs)==3\n", + " test_voxels_averaged[i] = torch.mean(test_voxels[None,locs], dim=1)\n", + "\n", + "# Prepare image list for input to GNet\n", + "recon_list = []\n", + "for i in range(all_recons.shape[0]):\n", + " img = all_recons[i].detach()\n", + " img = transforms.ToPILImage()(img)\n", + " recon_list.append(img)" + ] + }, + { + "cell_type": "markdown", + "id": "007f27d3-5e45-496b-b666-b437e916c7f1", + "metadata": {}, + "source": [ + "### Calculate Brain Correlation scores for each brain area" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "528db098-6977-4dbd-9bc6-dfd6a96e0fc7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from torchmetrics import PearsonCorrCoef\n", + "GNet = GNet8_Encoder(device=device,subject=subj,model_path=f\"{cache_dir}/gnet_multisubject.pt\")\n", + "PeC = PearsonCorrCoef(num_outputs=len(recon_list))\n", + "beta_primes = GNet.predict(recon_list)\n", + "\n", + "region_brain_correlations = {}\n", + "for region, mask in subject_masks.items():\n", + " score = PeC(test_voxels_averaged[:,mask].moveaxis(0,1), beta_primes[:,mask].moveaxis(0,1))\n", + " region_brain_correlations[region] = float(torch.mean(score))\n", + "print(region_brain_correlations)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b794c2d7-ebba-4993-a09d-ffb314cb30e8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Create a dictionary to store variable names and their corresponding values\n", + "import pandas as pd\n", + "data = {\n", + " \"Metric\": [\"PixCorr\", \"SSIM\", \"AlexNet(2)\", \"AlexNet(5)\", \"InceptionV3\", \"CLIP\", \"EffNet-B\", \"SwAV\", \"FwdRetrieval\", \"BwdRetrieval\",\n", + " \"Brain Corr. nsd_general\", \"Brain Corr. V1\", \"Brain Corr. V2\", \"Brain Corr. V3\", \"Brain Corr. V4\", \"Brain Corr. higher_vis\"],\n", + " \"Value\": [pixcorr, ssim, alexnet2, alexnet5, inception, clip_, effnet, swav, percent_correct_fwd, percent_correct_bwd, \n", + " region_brain_correlations[\"nsd_general\"], region_brain_correlations[\"V1\"], region_brain_correlations[\"V2\"], region_brain_correlations[\"V3\"], region_brain_correlations[\"V4\"], region_brain_correlations[\"higher_vis\"]]}\n", + "\n", + "df = pd.DataFrame(data)\n", + "print(model_name_plus_suffix)\n", + "print(df.to_string(index=False))\n", + "print(df[\"Value\"].to_string(index=False))\n", + "\n", + "# save table to txt file\n", + "os.makedirs('tables/',exist_ok=True)\n", + "df[\"Value\"].to_csv(f'tables/{model_name_plus_suffix}.csv', sep='\\t', index=False)" + ] + }, + { + "cell_type": "markdown", + "id": "78a64c17-200b-4278-9433-a52ba388f988", + "metadata": {}, + "source": [ + "# Captions evaluation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "20999416-35c5-4604-a69d-b89687d44f00", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "all_git_generated_captions = torch.load(f\"evals/all_git_generated_captions.pt\")" + ] + }, + { + "cell_type": "markdown", + "id": "44e6d2de-e303-4197-86fc-a4328fc7169b", + "metadata": {}, + "source": [ + "## Meteor" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e7159fa8-234d-4809-9c44-69fc86d7d668", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3f02f9939a254de386e7f37df4794c5d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Downloading builder script: 0%| | 0.00/6.93k [00:00 8: + _, _, voxels, all_images = utils.load_imageryrf(subject=subj-8, mode=mode, stimtype="object", average=False, nest=True, split=True, data_root = imagery_data_path) +elif mode == "shared1000": + x_train, valid_nsd_ids_train, x_test, test_nsd_ids = utils.load_nsd(subject=subj, data_path=data_path) + voxels = torch.mean(x_test, dim=1, keepdim=True) + print(f"Loaded subj {subj} test betas! {voxels.shape}") + f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') + images = f['images'] + + all_images = torch.zeros((len(test_nsd_ids), 3, 224, 224)) + for i, idx in enumerate(test_nsd_ids): + all_images[i] = torch.from_numpy(images[idx]) + del images, f + print(f"Filtered down to only the {len(test_nsd_ids)} test images for subject {subj}!") +else: + voxels, all_images = utils.load_nsd_mental_imagery(subject=subj, + mode=mode, + stimtype="all", + average=True, + nest=False, + data_root = imagery_data_path) +print(voxels.shape) +num_voxels = voxels.shape[-1] +plotting = False + + +# In[5]: + + +# voxels = {} +# # Load hdf5 data for betas +# f = h5py.File(f'{data_path}/betas_all_subj0{subj}_fp32_renorm.hdf5', 'r') +# betas = f['betas'][:] +# betas = torch.Tensor(betas).to("cpu") +# num_voxels = betas[0].shape[-1] +# voxels[f'subj0{subj}'] = betas +# print(f"num_voxels for subj0{subj}: {num_voxels}") + +# if not new_test: # using old test set from before full dataset released (used in original MindEye paper) +# if subj==3: +# num_test=2113 +# elif subj==4: +# num_test=1985 +# elif subj==6: +# num_test=2113 +# elif subj==8: +# num_test=1985 +# else: +# num_test=2770 +# test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +# else: # using larger test set from after full dataset released +# if subj==3: +# num_test=2371 +# elif subj==4: +# num_test=2188 +# elif subj==6: +# num_test=2371 +# elif subj==8: +# num_test=2188 +# else: +# num_test=3000 +# test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" + +# print(test_url) +# def my_split_by_node(urls): return urls +# test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ +# .decode("torch")\ +# .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ +# .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +# test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +# print(f"Loaded test dl for subj{subj}!\n") + + +# In[6]: + + +# # Prep images but don't load them all to memory +# f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +# images = f['images'] + +# # Prep test voxels and indices of test images +# test_images_idx = [] +# test_voxels_idx = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_voxels = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()] +# test_voxels_idx = np.append(test_images_idx, behav[:,0,5].cpu().numpy()) +# test_images_idx = np.append(test_images_idx, behav[:,0,0].cpu().numpy()) +# test_images_idx = test_images_idx.astype(int) +# test_voxels_idx = test_voxels_idx.astype(int) + +# assert (test_i+1) * num_test == len(test_voxels) == len(test_images_idx) +# print(test_i, len(test_voxels), len(test_images_idx), len(np.unique(test_images_idx))) + + +# In[7]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) +clip_seq_dim = 256 +clip_emb_dim = 1664 + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +model.ridge = RidgeRegression([num_voxels], out_features=hidden_dim) + +from diffusers.models.vae import Decoder +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.ridge) +utils.count_params(model.backbone) +utils.count_params(model) + +# setup diffusion prior network +out_dim = clip_emb_dim +depth = 6 +dim_head = 52 +heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim +timesteps = 100 + +prior_network = PriorNetwork( + dim=out_dim, + depth=depth, + dim_head=dim_head, + heads=heads, + causal=False, + num_tokens = clip_seq_dim, + learned_query_mode="pos_emb" + ) + +model.diffusion_prior = BrainDiffusionPrior( + net=prior_network, + image_embed_dim=out_dim, + condition_on_text_encodings=False, + timesteps=timesteps, + cond_drop_prob=0.2, + image_embed_scale=None, +) +model.to(device) + +utils.count_params(model.diffusion_prior) +utils.count_params(model) + +# Load pretrained model ckpt +tag='last' +outdir = os.path.abspath(f'../train_logs/{model_name}') +print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") +try: + checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + model.load_state_dict(state_dict, strict=True) + del checkpoint +except: # probably ckpt is saved using deepspeed format + import deepspeed + state_dict = deepspeed.utils.zero_to_fp32.get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir=outdir, tag=tag) + model.load_state_dict(state_dict, strict=False) + del state_dict +print("ckpt loaded!") + + +# In[8]: + + +# setup text caption networks +from transformers import AutoProcessor, AutoModelForCausalLM +from modeling_git import GitForCausalLMClipEmb +processor = AutoProcessor.from_pretrained("microsoft/git-large-coco") +clip_text_model = GitForCausalLMClipEmb.from_pretrained("microsoft/git-large-coco") +clip_text_model.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4 +clip_text_model.eval().requires_grad_(False) +clip_text_seq_dim = 257 +clip_text_emb_dim = 1024 + +class CLIPConverter(torch.nn.Module): + def __init__(self): + super(CLIPConverter, self).__init__() + self.linear1 = nn.Linear(clip_seq_dim, clip_text_seq_dim) + self.linear2 = nn.Linear(clip_emb_dim, clip_text_emb_dim) + def forward(self, x): + x = x.permute(0,2,1) + x = self.linear1(x) + x = self.linear2(x.permute(0,2,1)) + return x + +clip_convert = CLIPConverter() +state_dict = torch.load(f"{cache_dir}/bigG_to_L_epoch8.pth", map_location='cpu')['model_state_dict'] +clip_convert.load_state_dict(state_dict, strict=True) +clip_convert.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4 +del state_dict + + +# In[9]: + + +# prep unCLIP +config = OmegaConf.load("generative_models/configs/unclip6.yaml") +config = OmegaConf.to_container(config, resolve=True) +unclip_params = config["model"]["params"] +network_config = unclip_params["network_config"] +denoiser_config = unclip_params["denoiser_config"] +first_stage_config = unclip_params["first_stage_config"] +conditioner_config = unclip_params["conditioner_config"] +sampler_config = unclip_params["sampler_config"] +scale_factor = unclip_params["scale_factor"] +disable_first_stage_autocast = unclip_params["disable_first_stage_autocast"] +offset_noise_level = unclip_params["loss_fn_config"]["params"]["offset_noise_level"] + +first_stage_config['target'] = 'sgm.models.autoencoder.AutoencoderKL' +sampler_config['params']['num_steps'] = 38 + +diffusion_engine = DiffusionEngine(network_config=network_config, + denoiser_config=denoiser_config, + first_stage_config=first_stage_config, + conditioner_config=conditioner_config, + sampler_config=sampler_config, + scale_factor=scale_factor, + disable_first_stage_autocast=disable_first_stage_autocast) +# set to inference +diffusion_engine.eval().requires_grad_(False) +diffusion_engine.to(device) + +ckpt_path = f'{cache_dir}/unclip6_epoch0_step110000.ckpt' +ckpt = torch.load(ckpt_path, map_location='cpu') +diffusion_engine.load_state_dict(ckpt['state_dict']) + +batch={"jpg": torch.randn(1,3,1,1).to(device), # jpg doesnt get used, it's just a placeholder + "original_size_as_tuple": torch.ones(1, 2).to(device) * 768, + "crop_coords_top_left": torch.zeros(1, 2).to(device)} +out = diffusion_engine.conditioner(batch) +vector_suffix = out["vector"].to(device) +print("vector_suffix", vector_suffix.shape) + + +# In[10]: + + +from tqdm.auto import tqdm +# get all reconstructions +model.to(device) +model.eval().requires_grad_(False) + +final_all_recons = None +final_all_blurryrecons = None +final_all_predcaptions = [] +final_all_clipvoxels = None + +for rep in tqdm(range(gen_rep)): + # all_images = None + all_blurryrecons = None + all_recons = None + all_predcaptions = [] + all_clipvoxels = None + + minibatch_size = 1 + num_samples_per_image = 1 + assert num_samples_per_image == 1 + + if utils.is_interactive(): plotting=False + + with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16): + for idx, imagery_voxel in enumerate(voxels): + # uniq_imgs = np.unique(test_images_idx)[batch:batch+minibatch_size] + # voxel = None + # for uniq_img in uniq_imgs: + # locs = np.where(test_images_idx==uniq_img)[0] + # if len(locs)==1: + # locs = locs.repeat(3) + # elif len(locs)==2: + # locs = locs.repeat(2)[:3] + # assert len(locs)==3 + # if voxel is None: + # voxel = test_voxels[None,locs] # 1, num_image_repetitions, num_voxels + # else: + # voxel = torch.vstack((voxel, test_voxels[None,locs])) + voxel = imagery_voxel.to(device) + print(voxel.shape, voxel.shape) + for rep in range(1): + voxel_ridge = model.ridge(voxel.unsqueeze(0),0) # 0th index of subj_list + backbone0, clip_voxels0, blurry_image_enc0 = model.backbone(voxel_ridge) + if rep==0: + clip_voxels = clip_voxels0 + backbone = backbone0 + blurry_image_enc = blurry_image_enc0[0] + else: + clip_voxels += clip_voxels0 + backbone += backbone0 + blurry_image_enc += blurry_image_enc0[0] + clip_voxels /= 1 + backbone /= 1 + blurry_image_enc /= 1 + + # Save retrieval submodule outputs + if all_clipvoxels is None: + all_clipvoxels = clip_voxels.cpu() + else: + all_clipvoxels = torch.vstack((all_clipvoxels, clip_voxels.cpu())) + + # Feed voxels through OpenCLIP-bigG diffusion prior + prior_out = model.diffusion_prior.p_sample_loop(backbone.shape, + text_cond = dict(text_embed = backbone), + cond_scale = 1., timesteps = 20) + + pred_caption_emb = clip_convert(prior_out) + generated_ids = clip_text_model.generate(pixel_values=pred_caption_emb, max_length=20) + generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True) + all_predcaptions = np.hstack((all_predcaptions, generated_caption)) + print(generated_caption) + + # Feed diffusion prior outputs through unCLIP + for i in range(len(voxel)): + samples = utils.unclip_recon(prior_out[[i]], + diffusion_engine, + vector_suffix, + num_samples=num_samples_per_image) + if all_recons is None: + all_recons = samples.cpu() + else: + all_recons = torch.vstack((all_recons, samples.cpu())) + if plotting: + for s in range(num_samples_per_image): + plt.figure(figsize=(2,2)) + plt.imshow(transforms.ToPILImage()(samples[s])) + plt.axis('off') + plt.show() + + if blurry_recon: + blurred_image = (autoenc.decode(blurry_image_enc/0.18215).sample/ 2 + 0.5).clamp(0,1) + + for i in range(len(voxel)): + im = torch.Tensor(blurred_image[i]) + if all_blurryrecons is None: + all_blurryrecons = im[None].cpu() + else: + all_blurryrecons = torch.vstack((all_blurryrecons, im[None].cpu())) + if plotting: + plt.figure(figsize=(2,2)) + plt.imshow(transforms.ToPILImage()(im)) + plt.axis('off') + plt.show() + + if plotting: + print(model_name) + err # dont actually want to run the whole thing with plotting=True + + # resize outputs before saving + imsize = 256 + all_recons = transforms.Resize((imsize,imsize))(all_recons).float() + if blurry_recon: + all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float() + + # saving + print(all_recons.shape) + # # You can find the all_images file on huggingface: https://huggingface.co/datasets/pscotti/mindeyev2/tree/main/evals + # torch.save(all_images,"evals/all_images.pt") + # if blurry_recon: + # torch.save(all_blurryrecons,f"evals/{model_name}/{model_name}_all_blurryrecons.pt") + # torch.save(all_recons,f"evals/{model_name}/{model_name}_all_recons.pt") + # torch.save(all_predcaptions,f"evals/{model_name}/{model_name}_all_predcaptions.pt") + # torch.save(all_clipvoxels,f"evals/{model_name}/{model_name}_all_clipvoxels.pt") + + if final_all_recons is None: + if blurry_recon: + final_all_blurryrecons = all_blurryrecons.unsqueeze(1) + final_all_recons = all_recons.unsqueeze(1) + final_all_predcaptions = all_predcaptions.copy() + final_all_clipvoxels = all_clipvoxels.unsqueeze(1) + else: + if blurry_recon: + final_all_blurryrecons = torch.cat((final_all_blurryrecons, all_blurryrecons.unsqueeze(1)), dim=1) + final_all_recons = torch.cat((final_all_recons, all_recons.unsqueeze(1)), dim=1) + final_all_predcaptions = np.hstack((final_all_predcaptions, all_predcaptions)) + final_all_clipvoxels = torch.cat((final_all_clipvoxels, all_clipvoxels.unsqueeze(1)), dim=1) + + +# saving +print(final_all_recons.shape) +# You can find the all_images file on huggingface: https://huggingface.co/datasets/pscotti/mindeyev2/tree/main/evals +# torch.save(all_images,"evals/all_images.pt") + + +# if blurry_recon: +# torch.save(final_blurryrecons.half(),f"evals/{model_name}/{model_name}_all_blurryrecons_{mode}.pt") +# torch.save(final_recons.half(),f"evals/{model_name}/{model_name}_all_recons_{mode}.pt") + +if blurry_recon: + torch.save(final_all_blurryrecons,f"evals/{model_name}/{model_name}_all_blurryrecons_{mode}.pt") +torch.save(final_all_recons,f"evals/{model_name}/{model_name}_all_recons_{mode}.pt") +torch.save(final_all_predcaptions,f"evals/{model_name}/{model_name}_all_predcaptions_{mode}.pt") +torch.save(final_all_clipvoxels,f"evals/{model_name}/{model_name}_all_clipvoxels_{mode}.pt") + + +print(f"saved {model_name} outputs!") + +if not utils.is_interactive(): + sys.exit(0) + + +# In[11]: + + +torch.save(all_images,"evals/all_images.pt") + diff --git a/MindEyeV2/src/recon_inference_old.ipynb b/MindEyeV2/src/recon_inference_old.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5cd8b40b333a870a618c906ae1c751fc00f213b2 --- /dev/null +++ b/MindEyeV2/src/recon_inference_old.ipynb @@ -0,0 +1,760 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f16c9d4c-66cb-4692-a61d-9aa86a8765d0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: cuda\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "import webdataset as wds\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from accelerate import Accelerator\n", + "\n", + "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n", + "sys.path.append('generative_models/')\n", + "import sgm\n", + "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder, FrozenOpenCLIPEmbedder2\n", + "from generative_models.sgm.models.diffusion import DiffusionEngine\n", + "from generative_models.sgm.util import append_dims\n", + "from omegaconf import OmegaConf\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "from models import *\n", + "\n", + "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "plotting = False" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_3sess_24bs\n", + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_3sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " model_name = \"final_subj01_pretrained_3sess_24bs\"\n", + " print(\"model_name:\", model_name)\n", + "\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset \\\n", + " --model_name={model_name} --subj=1 \\\n", + " --hidden_dim=4096 --n_blocks=4 --new_test\"\n", + " print(jupyter_args)\n", + " jupyter_args = jupyter_args.split()\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "49e5dae4-606d-4dc6-b420-df9e4c14737e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"will load ckpt for model found in ../train_logs/model_name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=os.getcwd(),\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--cache_dir\", type=str, default=os.getcwd(),\n", + " help=\"Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n", + " help=\"Validate on which subject?\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_blocks\",type=int,default=4,\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=2048,\n", + ")\n", + "parser.add_argument(\n", + " \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + " \n", + "# seed all random functions\n", + "utils.seed_everything(seed)\n", + "\n", + "# make output directory\n", + "os.makedirs(\"evals\",exist_ok=True)\n", + "os.makedirs(f\"evals/{model_name}\",exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "64672583-9f00-46f5-8d4e-00e4c7068a1d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num_voxels for subj01: 15724\n", + "/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar\n", + "Loaded test dl for subj1!\n", + "\n" + ] + } + ], + "source": [ + "voxels = {}\n", + "# Load hdf5 data for betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}_fp32_renorm.hdf5', 'r')\n", + "betas = f['betas'][:]\n", + "betas = torch.Tensor(betas).to(\"cpu\")\n", + "num_voxels = betas[0].shape[-1]\n", + "voxels[f'subj0{subj}'] = betas\n", + "print(f\"num_voxels for subj0{subj}: {num_voxels}\")\n", + "\n", + "if not new_test: # using old test set from before full dataset released (used in original MindEye paper)\n", + " if subj==3:\n", + " num_test=2113\n", + " elif subj==4:\n", + " num_test=1985\n", + " elif subj==6:\n", + " num_test=2113\n", + " elif subj==8:\n", + " num_test=1985\n", + " else:\n", + " num_test=2770\n", + " test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "else: # using larger test set from after full dataset released\n", + " if subj==3:\n", + " num_test=2371\n", + " elif subj==4:\n", + " num_test=2188\n", + " elif subj==6:\n", + " num_test=2371\n", + " elif subj==8:\n", + " num_test=2188\n", + " else:\n", + " num_test=3000\n", + " test_url = f\"{data_path}/wds/subj0{subj}/new_test/\" + \"0.tar\"\n", + " \n", + "print(test_url)\n", + "def my_split_by_node(urls): return urls\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True)\n", + "print(f\"Loaded test dl for subj{subj}!\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a3cbeea8-e95b-48d9-9bc2-91af260c93d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3000 3000 1000\n" + ] + } + ], + "source": [ + "# Prep images but don't load them all to memory\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images']\n", + "\n", + "# Prep test voxels and indices of test images\n", + "test_images_idx = []\n", + "test_voxels_idx = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_voxels = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()]\n", + " test_voxels_idx = np.append(test_images_idx, behav[:,0,5].cpu().numpy())\n", + " test_images_idx = np.append(test_images_idx, behav[:,0,0].cpu().numpy())\n", + "test_images_idx = test_images_idx.astype(int)\n", + "test_voxels_idx = test_voxels_idx.astype(int)\n", + "\n", + "assert (test_i+1) * num_test == len(test_voxels) == len(test_images_idx)\n", + "print(test_i, len(test_voxels), len(test_images_idx), len(np.unique(test_images_idx)))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3afc4858-b6a6-4a52-9303-b4a50ea5cc0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n", + "param counts:\n", + "64,409,600 total\n", + "64,409,600 trainable\n", + "param counts:\n", + "1,903,020,028 total\n", + "1,903,020,028 trainable\n", + "param counts:\n", + "1,967,429,628 total\n", + "1,967,429,628 trainable\n", + "param counts:\n", + "259,865,216 total\n", + "259,865,200 trainable\n", + "param counts:\n", + "2,227,294,844 total\n", + "2,227,294,828 trainable\n", + "\n", + "---loading /weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last.pth ckpt---\n", + "\n", + "[2024-11-07 02:38:38,226] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "Processing zero checkpoint '/weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last'\n", + "Detected checkpoint of type zero stage ZeroStageEnum.gradients, world_size: 8\n", + "Parsing checkpoint created by deepspeed==0.12.2\n", + "Reconstructed Frozen fp32 state dict with 1 params 16 elements\n", + "Reconstructed fp32 state dict with 230 params 2227294828 elements\n", + "ckpt loaded!\n" + ] + } + ], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", + " version=\"laion2b_s39b_b160k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + ")\n", + "clip_img_embedder.to(device)\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1664\n", + "\n", + "if blurry_recon:\n", + " from diffusers import AutoencoderKL\n", + " autoenc = AutoencoderKL(\n", + " down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'],\n", + " up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'],\n", + " block_out_channels=[128, 256, 512, 512],\n", + " layers_per_block=2,\n", + " sample_size=256,\n", + " )\n", + " ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth')\n", + " autoenc.load_state_dict(ckpt)\n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)\n", + " \n", + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer to enable regularization\n", + " def __init__(self, input_sizes, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linears = torch.nn.ModuleList([\n", + " torch.nn.Linear(input_size, out_features) for input_size in input_sizes\n", + " ])\n", + " def forward(self, x, subj_idx):\n", + " out = self.linears[subj_idx](x[:,0]).unsqueeze(1)\n", + " return out\n", + " \n", + "model.ridge = RidgeRegression([num_voxels], out_features=hidden_dim)\n", + "\n", + "from diffusers.models.vae import Decoder\n", + "from models import BrainNetwork\n", + "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, \n", + " clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) \n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# setup diffusion prior network\n", + "out_dim = clip_emb_dim\n", + "depth = 6\n", + "dim_head = 52\n", + "heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n", + "timesteps = 100\n", + "\n", + "prior_network = PriorNetwork(\n", + " dim=out_dim,\n", + " depth=depth,\n", + " dim_head=dim_head,\n", + " heads=heads,\n", + " causal=False,\n", + " num_tokens = clip_seq_dim,\n", + " learned_query_mode=\"pos_emb\"\n", + " )\n", + "\n", + "model.diffusion_prior = BrainDiffusionPrior(\n", + " net=prior_network,\n", + " image_embed_dim=out_dim,\n", + " condition_on_text_encodings=False,\n", + " timesteps=timesteps,\n", + " cond_drop_prob=0.2,\n", + " image_embed_scale=None,\n", + ")\n", + "model.to(device)\n", + "\n", + "utils.count_params(model.diffusion_prior)\n", + "utils.count_params(model)\n", + "\n", + "# Load pretrained model ckpt\n", + "tag='last'\n", + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n", + "try:\n", + " checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu')\n", + " state_dict = checkpoint['model_state_dict']\n", + " model.load_state_dict(state_dict, strict=True)\n", + " del checkpoint\n", + "except: # probably ckpt is saved using deepspeed format\n", + " import deepspeed\n", + " state_dict = deepspeed.utils.zero_to_fp32.get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir=outdir, tag=tag)\n", + " model.load_state_dict(state_dict, strict=False)\n", + " del state_dict\n", + "print(\"ckpt loaded!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "295824db-ab3d-450c-90fb-f656e48994ba", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/fmri/lib/python3.11/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": [ + "# setup text caption networks\n", + "from transformers import AutoProcessor, AutoModelForCausalLM\n", + "from modeling_git import GitForCausalLMClipEmb\n", + "processor = AutoProcessor.from_pretrained(\"microsoft/git-large-coco\")\n", + "clip_text_model = GitForCausalLMClipEmb.from_pretrained(\"microsoft/git-large-coco\")\n", + "clip_text_model.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4\n", + "clip_text_model.eval().requires_grad_(False)\n", + "clip_text_seq_dim = 257\n", + "clip_text_emb_dim = 1024\n", + "\n", + "class CLIPConverter(torch.nn.Module):\n", + " def __init__(self):\n", + " super(CLIPConverter, self).__init__()\n", + " self.linear1 = nn.Linear(clip_seq_dim, clip_text_seq_dim)\n", + " self.linear2 = nn.Linear(clip_emb_dim, clip_text_emb_dim)\n", + " def forward(self, x):\n", + " x = x.permute(0,2,1)\n", + " x = self.linear1(x)\n", + " x = self.linear2(x.permute(0,2,1))\n", + " return x\n", + " \n", + "clip_convert = CLIPConverter()\n", + "state_dict = torch.load(f\"{cache_dir}/bigG_to_L_epoch8.pth\", map_location='cpu')['model_state_dict']\n", + "clip_convert.load_state_dict(state_dict, strict=True)\n", + "clip_convert.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4\n", + "del state_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f726f617-39f5-49e2-8d0c-d11d27d01c30", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", + "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False\n", + "Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "vector_suffix torch.Size([1, 1024])\n" + ] + } + ], + "source": [ + "# prep unCLIP\n", + "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n", + "config = OmegaConf.to_container(config, resolve=True)\n", + "unclip_params = config[\"model\"][\"params\"]\n", + "network_config = unclip_params[\"network_config\"]\n", + "denoiser_config = unclip_params[\"denoiser_config\"]\n", + "first_stage_config = unclip_params[\"first_stage_config\"]\n", + "conditioner_config = unclip_params[\"conditioner_config\"]\n", + "sampler_config = unclip_params[\"sampler_config\"]\n", + "scale_factor = unclip_params[\"scale_factor\"]\n", + "disable_first_stage_autocast = unclip_params[\"disable_first_stage_autocast\"]\n", + "offset_noise_level = unclip_params[\"loss_fn_config\"][\"params\"][\"offset_noise_level\"]\n", + "\n", + "first_stage_config['target'] = 'sgm.models.autoencoder.AutoencoderKL'\n", + "sampler_config['params']['num_steps'] = 38\n", + "\n", + "diffusion_engine = DiffusionEngine(network_config=network_config,\n", + " denoiser_config=denoiser_config,\n", + " first_stage_config=first_stage_config,\n", + " conditioner_config=conditioner_config,\n", + " sampler_config=sampler_config,\n", + " scale_factor=scale_factor,\n", + " disable_first_stage_autocast=disable_first_stage_autocast)\n", + "# set to inference\n", + "diffusion_engine.eval().requires_grad_(False)\n", + "diffusion_engine.to(device)\n", + "\n", + "ckpt_path = f'{cache_dir}/unclip6_epoch0_step110000.ckpt'\n", + "ckpt = torch.load(ckpt_path, map_location='cpu')\n", + "diffusion_engine.load_state_dict(ckpt['state_dict'])\n", + "\n", + "batch={\"jpg\": torch.randn(1,3,1,1).to(device), # jpg doesnt get used, it's just a placeholder\n", + " \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n", + " \"crop_coords_top_left\": torch.zeros(1, 2).to(device)}\n", + "out = diffusion_engine.conditioner(batch)\n", + "vector_suffix = out[\"vector\"].to(device)\n", + "print(\"vector_suffix\", vector_suffix.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c6a706a3-d151-4643-bb34-7d08aa7361c8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1000 [00:06 100\u001b[0m \u001b[43merr\u001b[49m \u001b[38;5;66;03m# dont actually want to run the whole thing with plotting=True\u001b[39;00m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;66;03m# resize outputs before saving\u001b[39;00m\n\u001b[1;32m 103\u001b[0m imsize \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m256\u001b[39m\n", + "\u001b[0;31mNameError\u001b[0m: name 'err' is not defined" + ] + } + ], + "source": [ + "# get all reconstructions\n", + "model.to(device)\n", + "model.eval().requires_grad_(False)\n", + "\n", + "# all_images = None\n", + "all_blurryrecons = None\n", + "all_recons = None\n", + "all_predcaptions = []\n", + "all_clipvoxels = None\n", + "\n", + "minibatch_size = 1\n", + "num_samples_per_image = 1\n", + "assert num_samples_per_image == 1\n", + "\n", + "if utils.is_interactive(): plotting=True\n", + "\n", + "with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16):\n", + " for batch in tqdm(range(0,len(np.unique(test_images_idx)),minibatch_size)):\n", + " uniq_imgs = np.unique(test_images_idx)[batch:batch+minibatch_size]\n", + " voxel = None\n", + " for uniq_img in uniq_imgs:\n", + " locs = np.where(test_images_idx==uniq_img)[0]\n", + " if len(locs)==1:\n", + " locs = locs.repeat(3)\n", + " elif len(locs)==2:\n", + " locs = locs.repeat(2)[:3]\n", + " assert len(locs)==3\n", + " if voxel is None:\n", + " voxel = test_voxels[None,locs] # 1, num_image_repetitions, num_voxels\n", + " else:\n", + " voxel = torch.vstack((voxel, test_voxels[None,locs]))\n", + " voxel = voxel.to(device)\n", + " \n", + " for rep in range(3):\n", + " voxel_ridge = model.ridge(voxel[:,[rep]],0) # 0th index of subj_list\n", + " backbone0, clip_voxels0, blurry_image_enc0 = model.backbone(voxel_ridge)\n", + " if rep==0:\n", + " clip_voxels = clip_voxels0\n", + " backbone = backbone0\n", + " blurry_image_enc = blurry_image_enc0[0]\n", + " else:\n", + " clip_voxels += clip_voxels0\n", + " backbone += backbone0\n", + " blurry_image_enc += blurry_image_enc0[0]\n", + " clip_voxels /= 3\n", + " backbone /= 3\n", + " blurry_image_enc /= 3\n", + " \n", + " # Save retrieval submodule outputs\n", + " if all_clipvoxels is None:\n", + " all_clipvoxels = clip_voxels.cpu()\n", + " else:\n", + " all_clipvoxels = torch.vstack((all_clipvoxels, clip_voxels.cpu()))\n", + " \n", + " # Feed voxels through OpenCLIP-bigG diffusion prior\n", + " prior_out = model.diffusion_prior.p_sample_loop(backbone.shape, \n", + " text_cond = dict(text_embed = backbone), \n", + " cond_scale = 1., timesteps = 20)\n", + " \n", + " pred_caption_emb = clip_convert(prior_out)\n", + " generated_ids = clip_text_model.generate(pixel_values=pred_caption_emb, max_length=20)\n", + " generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)\n", + " all_predcaptions = np.hstack((all_predcaptions, generated_caption))\n", + " print(generated_caption)\n", + " \n", + " # Feed diffusion prior outputs through unCLIP\n", + " for i in range(len(voxel)):\n", + " samples = utils.unclip_recon(prior_out[[i]],\n", + " diffusion_engine,\n", + " vector_suffix,\n", + " num_samples=num_samples_per_image)\n", + " if all_recons is None:\n", + " all_recons = samples.cpu()\n", + " else:\n", + " all_recons = torch.vstack((all_recons, samples.cpu()))\n", + " if plotting:\n", + " for s in range(num_samples_per_image):\n", + " plt.figure(figsize=(2,2))\n", + " plt.imshow(transforms.ToPILImage()(samples[s]))\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " if blurry_recon:\n", + " blurred_image = (autoenc.decode(blurry_image_enc/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " \n", + " for i in range(len(voxel)):\n", + " im = torch.Tensor(blurred_image[i])\n", + " if all_blurryrecons is None:\n", + " all_blurryrecons = im[None].cpu()\n", + " else:\n", + " all_blurryrecons = torch.vstack((all_blurryrecons, im[None].cpu()))\n", + " if plotting:\n", + " plt.figure(figsize=(2,2))\n", + " plt.imshow(transforms.ToPILImage()(im))\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " if plotting: \n", + " print(model_name)\n", + " err # dont actually want to run the whole thing with plotting=True\n", + "\n", + "# resize outputs before saving\n", + "imsize = 256\n", + "all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n", + "if blurry_recon: \n", + " all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float()\n", + " \n", + "# saving\n", + "print(all_recons.shape)\n", + "# # You can find the all_images file on huggingface: https://huggingface.co/datasets/pscotti/mindeyev2/tree/main/evals\n", + "# torch.save(all_images,\"evals/all_images.pt\") \n", + "if blurry_recon:\n", + " torch.save(all_blurryrecons,f\"evals/{model_name}/{model_name}_all_blurryrecons.pt\")\n", + "torch.save(all_recons,f\"evals/{model_name}/{model_name}_all_recons.pt\")\n", + "torch.save(all_predcaptions,f\"evals/{model_name}/{model_name}_all_predcaptions.pt\")\n", + "torch.save(all_clipvoxels,f\"evals/{model_name}/{model_name}_all_clipvoxels.pt\")\n", + "print(f\"saved {model_name} outputs!\")\n", + "\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fmri", + "language": "python", + "name": "fmri" + }, + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/MindEyeV2/src/recon_inference_old.py b/MindEyeV2/src/recon_inference_old.py new file mode 100644 index 0000000000000000000000000000000000000000..444fba706b176b0cbf2647eb11931ee5fa03521d --- /dev/null +++ b/MindEyeV2/src/recon_inference_old.py @@ -0,0 +1,492 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm +import webdataset as wds + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from accelerate import Accelerator + +# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main +sys.path.append('generative_models/') +import sgm +from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder, FrozenOpenCLIPEmbedder2 +from generative_models.sgm.models.diffusion import DiffusionEngine +from generative_models.sgm.util import append_dims +from omegaconf import OmegaConf + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils +from models import * + +accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +device = accelerator.device +print("device:",device) +plotting = False + + +# In[2]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + model_name = "final_subj01_pretrained_3sess_24bs" + print("model_name:", model_name) + + # other variables can be specified in the following string: + jupyter_args = f"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \ + --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset \ + --model_name={model_name} --subj=1 \ + --hidden_dim=4096 --n_blocks=4 --new_test" + print(jupyter_args) + jupyter_args = jupyter_args.split() + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[3]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="will load ckpt for model found in ../train_logs/model_name", +) +parser.add_argument( + "--data_path", type=str, default=os.getcwd(), + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--cache_dir", type=str, default=os.getcwd(), + help="Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8], + help="Validate on which subject?", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--n_blocks",type=int,default=4, +) +parser.add_argument( + "--hidden_dim",type=int,default=2048, +) +parser.add_argument( + "--new_test",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--seed",type=int,default=42, +) +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +# seed all random functions +utils.seed_everything(seed) + +# make output directory +os.makedirs("evals",exist_ok=True) +os.makedirs(f"evals/{model_name}",exist_ok=True) + + +# In[4]: + + +voxels = {} +# Load hdf5 data for betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}_fp32_renorm.hdf5', 'r') +betas = f['betas'][:] +betas = torch.Tensor(betas).to("cpu") +num_voxels = betas[0].shape[-1] +voxels[f'subj0{subj}'] = betas +print(f"num_voxels for subj0{subj}: {num_voxels}") + +if not new_test: # using old test set from before full dataset released (used in original MindEye paper) + if subj==3: + num_test=2113 + elif subj==4: + num_test=1985 + elif subj==6: + num_test=2113 + elif subj==8: + num_test=1985 + else: + num_test=2770 + test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +else: # using larger test set from after full dataset released + if subj==3: + num_test=2371 + elif subj==4: + num_test=2188 + elif subj==6: + num_test=2371 + elif subj==8: + num_test=2188 + else: + num_test=3000 + test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" + +print(test_url) +def my_split_by_node(urls): return urls +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +print(f"Loaded test dl for subj{subj}!\n") + + +# In[5]: + + +# Prep images but don't load them all to memory +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'] + +# Prep test voxels and indices of test images +test_images_idx = [] +test_voxels_idx = [] +for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + test_voxels = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()] + test_voxels_idx = np.append(test_images_idx, behav[:,0,5].cpu().numpy()) + test_images_idx = np.append(test_images_idx, behav[:,0,0].cpu().numpy()) +test_images_idx = test_images_idx.astype(int) +test_voxels_idx = test_voxels_idx.astype(int) + +assert (test_i+1) * num_test == len(test_voxels) == len(test_images_idx) +print(test_i, len(test_voxels), len(test_images_idx), len(np.unique(test_images_idx))) + + +# In[6]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) +clip_seq_dim = 256 +clip_emb_dim = 1664 + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +model.ridge = RidgeRegression([num_voxels], out_features=hidden_dim) + +from diffusers.models.vae import Decoder +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.ridge) +utils.count_params(model.backbone) +utils.count_params(model) + +# setup diffusion prior network +out_dim = clip_emb_dim +depth = 6 +dim_head = 52 +heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim +timesteps = 100 + +prior_network = PriorNetwork( + dim=out_dim, + depth=depth, + dim_head=dim_head, + heads=heads, + causal=False, + num_tokens = clip_seq_dim, + learned_query_mode="pos_emb" + ) + +model.diffusion_prior = BrainDiffusionPrior( + net=prior_network, + image_embed_dim=out_dim, + condition_on_text_encodings=False, + timesteps=timesteps, + cond_drop_prob=0.2, + image_embed_scale=None, +) +model.to(device) + +utils.count_params(model.diffusion_prior) +utils.count_params(model) + +# Load pretrained model ckpt +tag='last' +outdir = os.path.abspath(f'../train_logs/{model_name}') +print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") +try: + checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + model.load_state_dict(state_dict, strict=True) + del checkpoint +except: # probably ckpt is saved using deepspeed format + import deepspeed + state_dict = deepspeed.utils.zero_to_fp32.get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir=outdir, tag=tag) + model.load_state_dict(state_dict, strict=False) + del state_dict +print("ckpt loaded!") + + +# In[7]: + + +# setup text caption networks +from transformers import AutoProcessor, AutoModelForCausalLM +from modeling_git import GitForCausalLMClipEmb +processor = AutoProcessor.from_pretrained("microsoft/git-large-coco") +clip_text_model = GitForCausalLMClipEmb.from_pretrained("microsoft/git-large-coco") +clip_text_model.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4 +clip_text_model.eval().requires_grad_(False) +clip_text_seq_dim = 257 +clip_text_emb_dim = 1024 + +class CLIPConverter(torch.nn.Module): + def __init__(self): + super(CLIPConverter, self).__init__() + self.linear1 = nn.Linear(clip_seq_dim, clip_text_seq_dim) + self.linear2 = nn.Linear(clip_emb_dim, clip_text_emb_dim) + def forward(self, x): + x = x.permute(0,2,1) + x = self.linear1(x) + x = self.linear2(x.permute(0,2,1)) + return x + +clip_convert = CLIPConverter() +state_dict = torch.load(f"{cache_dir}/bigG_to_L_epoch8.pth", map_location='cpu')['model_state_dict'] +clip_convert.load_state_dict(state_dict, strict=True) +clip_convert.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4 +del state_dict + + +# In[8]: + + +# prep unCLIP +config = OmegaConf.load("generative_models/configs/unclip6.yaml") +config = OmegaConf.to_container(config, resolve=True) +unclip_params = config["model"]["params"] +network_config = unclip_params["network_config"] +denoiser_config = unclip_params["denoiser_config"] +first_stage_config = unclip_params["first_stage_config"] +conditioner_config = unclip_params["conditioner_config"] +sampler_config = unclip_params["sampler_config"] +scale_factor = unclip_params["scale_factor"] +disable_first_stage_autocast = unclip_params["disable_first_stage_autocast"] +offset_noise_level = unclip_params["loss_fn_config"]["params"]["offset_noise_level"] + +first_stage_config['target'] = 'sgm.models.autoencoder.AutoencoderKL' +sampler_config['params']['num_steps'] = 38 + +diffusion_engine = DiffusionEngine(network_config=network_config, + denoiser_config=denoiser_config, + first_stage_config=first_stage_config, + conditioner_config=conditioner_config, + sampler_config=sampler_config, + scale_factor=scale_factor, + disable_first_stage_autocast=disable_first_stage_autocast) +# set to inference +diffusion_engine.eval().requires_grad_(False) +diffusion_engine.to(device) + +ckpt_path = f'{cache_dir}/unclip6_epoch0_step110000.ckpt' +ckpt = torch.load(ckpt_path, map_location='cpu') +diffusion_engine.load_state_dict(ckpt['state_dict']) + +batch={"jpg": torch.randn(1,3,1,1).to(device), # jpg doesnt get used, it's just a placeholder + "original_size_as_tuple": torch.ones(1, 2).to(device) * 768, + "crop_coords_top_left": torch.zeros(1, 2).to(device)} +out = diffusion_engine.conditioner(batch) +vector_suffix = out["vector"].to(device) +print("vector_suffix", vector_suffix.shape) + + +# In[9]: + + +# get all reconstructions +model.to(device) +model.eval().requires_grad_(False) + +# all_images = None +all_blurryrecons = None +all_recons = None +all_predcaptions = [] +all_clipvoxels = None + +minibatch_size = 1 +num_samples_per_image = 1 +assert num_samples_per_image == 1 + +if utils.is_interactive(): plotting=True + +with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16): + for batch in tqdm(range(0,len(np.unique(test_images_idx)),minibatch_size)): + uniq_imgs = np.unique(test_images_idx)[batch:batch+minibatch_size] + voxel = None + for uniq_img in uniq_imgs: + locs = np.where(test_images_idx==uniq_img)[0] + if len(locs)==1: + locs = locs.repeat(3) + elif len(locs)==2: + locs = locs.repeat(2)[:3] + assert len(locs)==3 + if voxel is None: + voxel = test_voxels[None,locs] # 1, num_image_repetitions, num_voxels + else: + voxel = torch.vstack((voxel, test_voxels[None,locs])) + voxel = voxel.to(device) + + for rep in range(3): + voxel_ridge = model.ridge(voxel[:,[rep]],0) # 0th index of subj_list + backbone0, clip_voxels0, blurry_image_enc0 = model.backbone(voxel_ridge) + if rep==0: + clip_voxels = clip_voxels0 + backbone = backbone0 + blurry_image_enc = blurry_image_enc0[0] + else: + clip_voxels += clip_voxels0 + backbone += backbone0 + blurry_image_enc += blurry_image_enc0[0] + clip_voxels /= 3 + backbone /= 3 + blurry_image_enc /= 3 + + # Save retrieval submodule outputs + if all_clipvoxels is None: + all_clipvoxels = clip_voxels.cpu() + else: + all_clipvoxels = torch.vstack((all_clipvoxels, clip_voxels.cpu())) + + # Feed voxels through OpenCLIP-bigG diffusion prior + prior_out = model.diffusion_prior.p_sample_loop(backbone.shape, + text_cond = dict(text_embed = backbone), + cond_scale = 1., timesteps = 20) + + pred_caption_emb = clip_convert(prior_out) + generated_ids = clip_text_model.generate(pixel_values=pred_caption_emb, max_length=20) + generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True) + all_predcaptions = np.hstack((all_predcaptions, generated_caption)) + print(generated_caption) + + # Feed diffusion prior outputs through unCLIP + for i in range(len(voxel)): + samples = utils.unclip_recon(prior_out[[i]], + diffusion_engine, + vector_suffix, + num_samples=num_samples_per_image) + if all_recons is None: + all_recons = samples.cpu() + else: + all_recons = torch.vstack((all_recons, samples.cpu())) + if plotting: + for s in range(num_samples_per_image): + plt.figure(figsize=(2,2)) + plt.imshow(transforms.ToPILImage()(samples[s])) + plt.axis('off') + plt.show() + + if blurry_recon: + blurred_image = (autoenc.decode(blurry_image_enc/0.18215).sample/ 2 + 0.5).clamp(0,1) + + for i in range(len(voxel)): + im = torch.Tensor(blurred_image[i]) + if all_blurryrecons is None: + all_blurryrecons = im[None].cpu() + else: + all_blurryrecons = torch.vstack((all_blurryrecons, im[None].cpu())) + if plotting: + plt.figure(figsize=(2,2)) + plt.imshow(transforms.ToPILImage()(im)) + plt.axis('off') + plt.show() + + if plotting: + print(model_name) + err # dont actually want to run the whole thing with plotting=True + +# resize outputs before saving +imsize = 256 +all_recons = transforms.Resize((imsize,imsize))(all_recons).float() +if blurry_recon: + all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float() + +# saving +print(all_recons.shape) +# # You can find the all_images file on huggingface: https://huggingface.co/datasets/pscotti/mindeyev2/tree/main/evals +# torch.save(all_images,"evals/all_images.pt") +if blurry_recon: + torch.save(all_blurryrecons,f"evals/{model_name}/{model_name}_all_blurryrecons.pt") +torch.save(all_recons,f"evals/{model_name}/{model_name}_all_recons.pt") +torch.save(all_predcaptions,f"evals/{model_name}/{model_name}_all_predcaptions.pt") +torch.save(all_clipvoxels,f"evals/{model_name}/{model_name}_all_clipvoxels.pt") +print(f"saved {model_name} outputs!") + +if not utils.is_interactive(): + sys.exit(0) + diff --git a/MindEyeV2/src/wandb/debug-cli.ckadirt.log b/MindEyeV2/src/wandb/debug-cli.ckadirt.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MindEyeV2/src/wandb/debug-internal.log b/MindEyeV2/src/wandb/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..009de1435f77cf9083a53646b04348a2da292bd1 --- /dev/null +++ b/MindEyeV2/src/wandb/debug-internal.log @@ -0,0 +1,15806 @@ +2024-12-10 21:57:28,181 INFO StreamThr :843156 [internal.py:wandb_internal():85] W&B internal server running at pid: 843156, started at: 2024-12-10 21:57:28.180540 +2024-12-10 21:57:28,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status +2024-12-10 21:57:28,187 INFO WriterThread:843156 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/run-bold5k_nsdm1.wandb +2024-12-10 21:57:28,189 DEBUG SenderThread:843156 [sender.py:send():379] send: header +2024-12-10 21:57:28,199 DEBUG SenderThread:843156 [sender.py:send():379] send: run +2024-12-10 21:57:28,204 INFO SenderThread:843156 [sender.py:_setup_resume():749] checking resume status for None/mindeye/bold5k_nsdm1 +2024-12-10 21:57:28,554 INFO SenderThread:843156 [sender.py:_setup_resume():829] configured resuming with: ResumeState(resumed=True,step=0,history=0,events=0,output=3,runtime=0,wandb_runtime=None,summary={},config={'seed': {'desc': None, 'value': 42}, '_wandb': {'desc': None, 'value': {'t': {'1': [1, 5, 9, 11, 41, 49, 53, 55, 63, 71, 79, 83, 103], '2': [1, 5, 9, 11, 41, 49, 53, 55, 63, 71, 79, 83, 103], '3': [13, 14, 16, 23], '4': '3.11.10', '5': '0.17.1', '6': '4.37.2', '8': [5], '13': 'linux-x86_64'}, 'code_path': 'code/src/TrainB5k.py', 'framework': 'huggingface', 'start_time': 1733867727, 'cli_version': '0.17.1', 'is_jupyter_run': False, 'python_version': '3.11.10', 'is_kaggle_kernel': False, 'huggingface_version': '4.37.2'}}, 'max_lr': {'desc': None, 'value': 0.0003}, 'num_test': {'desc': None, 'value': 480}, 'mixup_pct': {'desc': None, 'value': 0.33}, 'batch_size': {'desc': None, 'value': 21}, 'blur_scale': {'desc': None, 'value': 0.5}, 'clip_scale': {'desc': None, 'value': 1}, 'model_name': {'desc': None, 'value': 'bold5k_nsdm1'}, 'num_epochs': {'desc': None, 'value': 80}, 'num_params': {'desc': None, 'value': 2239051016}, 'world_size': {'desc': None, 'value': 1}, 'ckpt_saving': {'desc': None, 'value': False}, 'distributed': {'desc': None, 'value': False}, 'num_devices': {'desc': None, 'value': 1}, 'prior_scale': {'desc': None, 'value': 30}, 'num_sessions': {'desc': None, 'value': 15}, 'ckpt_interval': {'desc': None, 'value': 999}, 'use_image_aug': {'desc': None, 'value': True}, 'global_batch_size': {'desc': None, 'value': '21'}, 'num_samples_per_epoch': {'desc': None, 'value': 4323}},tags=[]) +2024-12-10 21:57:28,697 INFO SenderThread:843156 [dir_watcher.py:__init__():211] watching files in: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files +2024-12-10 21:57:28,697 INFO SenderThread:843156 [sender.py:_start_run_threads():1188] run started: bold5k_nsdm1 with start time 1733867848.182576 +2024-12-10 21:57:28,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: check_version +2024-12-10 21:57:28,708 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: check_version +2024-12-10 21:57:28,779 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: run_start +2024-12-10 21:57:28,880 DEBUG HandlerThread:843156 [system_info.py:__init__():26] System info init +2024-12-10 21:57:28,880 DEBUG HandlerThread:843156 [system_info.py:__init__():41] System info init done +2024-12-10 21:57:28,880 INFO HandlerThread:843156 [system_monitor.py:start():194] Starting system monitor +2024-12-10 21:57:28,880 INFO SystemMonitor:843156 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-12-10 21:57:28,881 INFO SystemMonitor:843156 [interfaces.py:start():188] Started cpu monitoring +2024-12-10 21:57:28,881 INFO SystemMonitor:843156 [interfaces.py:start():188] Started disk monitoring +2024-12-10 21:57:28,882 INFO SystemMonitor:843156 [interfaces.py:start():188] Started gpu monitoring +2024-12-10 21:57:28,882 INFO SystemMonitor:843156 [interfaces.py:start():188] Started memory monitoring +2024-12-10 21:57:28,883 INFO SystemMonitor:843156 [interfaces.py:start():188] Started network monitoring +2024-12-10 21:57:29,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: python_packages +2024-12-10 21:57:29,318 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: python_packages +2024-12-10 21:57:29,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:57:29,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:29,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:57:29,487 DEBUG SenderThread:843156 [sender.py:send():379] send: telemetry +2024-12-10 21:57:29,699 INFO Thread-12 :843156 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/requirements.txt +2024-12-10 21:57:30,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:30,700 INFO Thread-12 :843156 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 21:57:31,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:32,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:32,703 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 21:57:33,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:33,705 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 21:57:33,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:57:34,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:35,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:36,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:37,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:38,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:39,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:57:39,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:40,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:41,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:42,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:43,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:44,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:57:44,319 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:57:44,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:44,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:57:45,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:46,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:47,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:48,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:49,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:50,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:57:50,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:51,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:52,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:53,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:54,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:55,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:57:55,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:56,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:57,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:58,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:57:59,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:57:59,319 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:57:59,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:00,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:00,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:00,761 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/config.yaml +2024-12-10 21:58:01,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:02,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:03,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:04,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:05,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:06,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:06,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:07,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:08,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:09,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:10,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:11,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:12,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:12,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:13,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:14,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:58:14,319 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:58:14,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:15,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:16,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:17,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:17,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:18,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:19,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:20,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:21,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:22,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:23,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:23,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:24,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:25,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:26,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:27,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:28,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:28,883 DEBUG SystemMonitor:843156 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-12-10 21:58:28,885 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 21:58:28,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:29,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:58:29,319 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:58:29,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:30,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:31,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:32,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:33,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:34,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:34,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:35,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:36,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:37,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:38,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:39,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:39,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:40,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:41,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:42,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:43,280 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 21:58:43,283 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 21:58:43,283 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 21:58:43,285 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 21:58:43,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:43,842 INFO Thread-12 :843156 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 21:58:44,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:58:44,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:58:44,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:44,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:44,843 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 21:58:45,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:46,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:47,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:48,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:49,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:50,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:50,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:51,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:52,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:53,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:54,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:55,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:58:55,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:56,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:57,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:58,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:58:58,887 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 21:58:59,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:58:59,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:58:59,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:00,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:00,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:01,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:02,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:03,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:04,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:05,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:06,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:06,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:07,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:08,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:09,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:10,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:11,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:11,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:12,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:13,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:14,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:59:14,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:59:14,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:15,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:16,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:16,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:17,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:18,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:19,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:20,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:21,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:22,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:22,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:23,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:24,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:25,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:26,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:27,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:27,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:28,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:28,889 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 21:59:29,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:59:29,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:59:29,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:30,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:31,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:32,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:32,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:33,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:34,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:35,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:36,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:37,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:38,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:38,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:39,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:40,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:41,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:42,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:43,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:43,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:44,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:59:44,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:59:44,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:45,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:46,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:47,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:48,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:48,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:49,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:50,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:51,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:52,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:53,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:54,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 21:59:54,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 21:59:54,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:54,458 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 21:59:54,459 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 21:59:54,463 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 21:59:54,983 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 21:59:54,984 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 21:59:55,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:56,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:57,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:58,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:58,891 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 21:59:59,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 21:59:59,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 21:59:59,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 21:59:59,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:00,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:01,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:02,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:03,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:04,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:05,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:05,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:06,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:07,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:08,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:09,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:10,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:11,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:11,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:12,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:13,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:14,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:00:14,321 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:00:14,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:15,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:16,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:16,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:17,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:18,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:19,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:20,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:21,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:22,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:22,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:23,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:24,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:25,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:26,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:27,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:27,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:28,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:28,893 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:00:29,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:00:29,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:00:29,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:30,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:31,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:32,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:32,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:33,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:34,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:35,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:36,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:37,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:38,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:38,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:39,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:40,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:41,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:42,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:43,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:44,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:00:44,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:00:44,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:44,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:45,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:46,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:47,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:48,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:49,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:50,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:50,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:51,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:52,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:53,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:54,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:55,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:56,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:00:56,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:57,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:58,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:00:58,895 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:00:59,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:00:59,320 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:00:59,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:00,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:01,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:01,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:02,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:03,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:04,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:05,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:05,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:01:05,693 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:01:05,693 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:01:05,695 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:01:06,146 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:01:06,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:06,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:07,149 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:01:07,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:08,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:09,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:10,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:11,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:12,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:12,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:13,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:14,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:01:14,321 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:01:14,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:15,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:16,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:17,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:17,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:18,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:19,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:20,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:21,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:22,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:23,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:23,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:24,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:25,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:26,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:27,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:28,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:28,897 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:01:28,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:29,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:01:29,321 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:01:29,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:30,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:31,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:32,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:33,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:34,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:34,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:35,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:36,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:37,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:38,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:39,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:39,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:40,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:41,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:42,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:43,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:44,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:01:44,321 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:01:44,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:44,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:45,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:46,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:47,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:48,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:49,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:50,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:50,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:51,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:52,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:53,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:54,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:55,327 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:01:55,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:56,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:57,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:58,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:01:58,898 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:01:59,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:01:59,321 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:01:59,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:00,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:00,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:01,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:02,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:03,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:04,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:05,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:06,327 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:06,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:07,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:08,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:09,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:10,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:11,327 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:11,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:12,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:13,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:14,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:02:14,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:02:14,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:15,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:16,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:16,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:16,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:02:16,929 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:02:16,929 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:02:16,932 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:02:17,289 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:02:17,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:18,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:19,293 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:02:19,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:20,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:21,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:22,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:22,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:23,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:24,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:25,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:26,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:27,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:28,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:28,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:28,899 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:02:29,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:02:29,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:02:29,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:30,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:31,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:32,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:33,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:33,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:34,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:35,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:36,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:37,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:38,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:39,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:39,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:40,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:41,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:42,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:43,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:44,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:44,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:02:44,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:02:44,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:45,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:46,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:47,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:48,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:49,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:50,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:50,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:51,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:52,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:53,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:54,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:55,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:02:55,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:56,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:57,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:58,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:02:58,903 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:02:59,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:02:59,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:02:59,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:00,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:00,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:01,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:02,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:03,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:04,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:05,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:06,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:06,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:07,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:08,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:09,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:10,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:11,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:11,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:12,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:13,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:14,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:03:14,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:03:14,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:15,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:16,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:16,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:17,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:18,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:19,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:20,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:21,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:22,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:22,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:23,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:24,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:25,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:26,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:27,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:27,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:27,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:03:27,581 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:03:27,582 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:03:27,584 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:03:28,445 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:03:28,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:28,903 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:03:29,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:03:29,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:03:29,447 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:03:29,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:30,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:31,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:32,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:32,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:33,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:34,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:35,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:36,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:37,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:38,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:38,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:39,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:40,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:41,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:42,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:43,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:44,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:03:44,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:03:44,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:44,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:45,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:46,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:47,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:48,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:49,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:50,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:50,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:51,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:52,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:53,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:54,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:55,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:56,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:03:56,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:57,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:58,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:03:58,906 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:03:59,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:03:59,422 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:03:59,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:00,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:01,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:01,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:02,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:03,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:04,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:05,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:06,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:07,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:07,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:08,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:09,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:10,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:11,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:12,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:13,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:13,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:14,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:04:14,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:04:14,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:15,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:16,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:17,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:18,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:18,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:19,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:20,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:21,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:22,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:23,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:24,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:24,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:25,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:26,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:27,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:28,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:28,908 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:04:29,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:04:29,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:04:29,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:29,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:30,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:31,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:32,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:33,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:34,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:35,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:35,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:36,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:37,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:38,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:39,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:40,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:40,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:41,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:04:41,085 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:04:41,085 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:04:41,088 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:04:41,604 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:04:41,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:42,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:43,608 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:04:43,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:44,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:04:44,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:04:44,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:45,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:45,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:46,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:47,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:48,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:49,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:50,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:51,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:51,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:52,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:53,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:54,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:55,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:56,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:04:56,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:57,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:58,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:04:58,910 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:04:59,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:04:59,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:04:59,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:00,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:01,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:01,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:02,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:03,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:04,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:05,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:06,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:07,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:07,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:08,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:09,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:10,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:11,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:12,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:12,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:13,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:14,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:05:14,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:05:14,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:15,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:16,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:17,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:17,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:18,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:19,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:20,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:21,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:22,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:23,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:23,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:24,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:25,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:26,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:27,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:28,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:28,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:28,911 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:05:29,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:05:29,423 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:05:29,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:30,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:31,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:32,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:33,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:33,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:34,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:35,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:36,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:37,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:38,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:39,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:39,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:40,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:41,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:42,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:43,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:44,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:05:44,424 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:05:44,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:44,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:45,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:46,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:47,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:48,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:49,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:50,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:50,734 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:51,734 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:52,734 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:53,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:05:53,017 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:05:53,018 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:05:53,020 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:05:53,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:53,741 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:05:54,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:55,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:55,744 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:05:56,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:05:56,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:57,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:58,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:05:58,913 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:05:59,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:05:59,424 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:05:59,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:00,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:01,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:01,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:02,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:03,735 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:04,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:05,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:06,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:07,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:07,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:08,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:09,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:10,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:11,736 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:12,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:12,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:13,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:14,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:06:14,424 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:06:14,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:15,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:16,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:17,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:17,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:18,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:19,737 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:20,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:21,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:22,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:23,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:23,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:24,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:25,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:26,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:27,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:28,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:28,915 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:06:28,917 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:29,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:06:29,424 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:06:29,738 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:30,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:31,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:32,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:33,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:34,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:34,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:35,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:36,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:37,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:38,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:39,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:39,739 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:40,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:41,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:42,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:43,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:44,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:06:44,424 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:06:44,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:44,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:45,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:46,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:47,740 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:48,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:49,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:50,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:50,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:51,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:52,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:53,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:54,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:55,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:06:55,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:56,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:57,741 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:58,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:06:58,917 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:06:59,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:06:59,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:06:59,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:00,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:00,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:01,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:02,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:03,743 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:04,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:05,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:07:05,605 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:07:05,605 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:07:05,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:05,607 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:07:05,742 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:05,881 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:07:06,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:07,743 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:07,884 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:07:08,743 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:09,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:10,743 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:11,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:11,743 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:12,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:13,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:14,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:07:14,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:07:14,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:15,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:16,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:16,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:17,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:18,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:19,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:20,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:21,744 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:22,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:22,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:23,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:24,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:25,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:26,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:27,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:27,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:28,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:28,918 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:07:29,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:07:29,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:07:29,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:30,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:31,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:32,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:32,745 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:33,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:34,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:35,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:36,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:37,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:38,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:38,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:39,746 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:40,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:41,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:42,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:43,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:44,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:07:44,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:07:44,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:44,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:45,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:46,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:47,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:48,747 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:49,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:50,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:50,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:51,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:52,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:53,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:54,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:55,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:56,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:07:56,748 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:57,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:58,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:07:58,921 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:07:59,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:07:59,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:07:59,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:00,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:01,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:01,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:02,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:03,749 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:04,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:05,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:06,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:07,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:07,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:08,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:09,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:10,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:11,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:12,750 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:13,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:13,751 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:14,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:08:14,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:08:14,751 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:15,751 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:16,751 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:17,751 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:18,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:08:18,061 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:08:18,061 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:08:18,063 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:08:18,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:19,018 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:08:19,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:19,797 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:20,020 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:08:20,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:21,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:22,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:23,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:24,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:24,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:25,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:26,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:27,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:28,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:28,923 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:08:29,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:08:29,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:08:29,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:29,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:30,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:31,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:32,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:33,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:34,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:35,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:35,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:36,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:37,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:38,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:39,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:40,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:41,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:41,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:42,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:43,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:44,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:08:44,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:08:44,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:45,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:46,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:46,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:47,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:48,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:49,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:50,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:51,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:52,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:52,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:53,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:54,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:55,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:56,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:57,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:08:57,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:58,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:08:58,924 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:08:59,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:08:59,425 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:08:59,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:00,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:01,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:02,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:02,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:03,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:04,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:05,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:06,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:07,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:08,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:08,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:09,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:10,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:11,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:12,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:13,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:14,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:09:14,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:09:14,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:14,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:15,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:16,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:17,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:18,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:19,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:20,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:20,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:21,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:22,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:23,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:24,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:25,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:26,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:26,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:27,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:28,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:28,926 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:09:29,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:09:29,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:09:29,818 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:30,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:31,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:09:31,234 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:09:31,234 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:09:31,236 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:09:31,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:32,152 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:09:32,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:32,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:33,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:34,157 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:09:34,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:35,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:36,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:37,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:37,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:38,819 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:39,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:40,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:41,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:42,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:43,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:43,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:44,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:09:44,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:09:44,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:45,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:46,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:47,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:48,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:48,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:49,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:50,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:51,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:52,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:53,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:54,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:54,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:55,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:56,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:57,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:58,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:09:58,927 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:09:59,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:09:59,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:09:59,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:09:59,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:00,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:01,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:02,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:03,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:04,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:05,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:05,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:06,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:07,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:08,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:09,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:10,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:10,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:11,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:12,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:13,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:14,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:10:14,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:10:14,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:15,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:15,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:16,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:17,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:18,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:19,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:20,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:21,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:21,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:22,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:23,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:24,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:25,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:26,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:26,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:27,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:28,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:28,929 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:10:29,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:10:29,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:10:29,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:30,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:31,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:31,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:32,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:33,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:34,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:35,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:36,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:37,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:37,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:38,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:39,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:40,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:41,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:42,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:42,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:43,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:10:43,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:43,830 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:10:43,830 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:10:43,832 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:10:44,296 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:10:44,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:10:44,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:10:44,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:45,298 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:10:45,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:46,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:47,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:47,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:48,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:49,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:50,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:51,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:52,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:53,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:53,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:54,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:55,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:56,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:57,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:58,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:10:58,931 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:10:58,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:10:59,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:10:59,426 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:10:59,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:00,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:01,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:02,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:03,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:04,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:04,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:05,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:06,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:07,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:08,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:09,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:09,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:10,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:11,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:12,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:13,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:14,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:11:14,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:11:14,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:14,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:15,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:16,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:17,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:18,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:19,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:20,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:20,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:21,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:22,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:23,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:24,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:25,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:26,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:26,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:27,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:28,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:28,934 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:11:29,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:11:29,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:11:29,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:30,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:31,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:31,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:32,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:33,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:34,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:35,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:36,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:37,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:37,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:38,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:39,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:40,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:41,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:42,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:43,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:43,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:44,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:11:44,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:11:44,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:45,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:46,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:47,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:48,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:48,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:49,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:50,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:51,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:52,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:53,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:54,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:54,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:55,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:11:55,802 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:11:55,802 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:11:55,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:55,835 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:11:56,341 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:11:56,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:57,345 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:11:57,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:58,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:11:58,937 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:11:59,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:11:59,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:11:59,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:11:59,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:00,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:01,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:02,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:03,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:04,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:05,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:05,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:06,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:07,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:08,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:09,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:10,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:10,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:11,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:12,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:13,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:14,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:12:14,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:12:14,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:15,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:15,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:16,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:17,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:18,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:19,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:20,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:21,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:21,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:22,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:23,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:24,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:25,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:26,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:26,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:27,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:28,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:28,939 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:12:29,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:12:29,427 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:12:29,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:30,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:31,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:31,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:32,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:33,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:34,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:35,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:36,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:37,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:37,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:38,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:39,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:40,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:41,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:42,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:42,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:43,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:44,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:12:44,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:12:44,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:45,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:46,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:47,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:47,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:48,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:49,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:50,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:51,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:52,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:53,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:53,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:54,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:55,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:56,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:57,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:58,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:12:58,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:12:58,940 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:12:59,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:12:59,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:12:59,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:00,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:01,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:02,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:03,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:03,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:04,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:05,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:06,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:07,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:08,516 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:13:08,517 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:13:08,517 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:13:08,519 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:13:08,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:09,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:09,504 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:13:09,504 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:13:09,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:10,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:11,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:12,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:13,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:14,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:13:14,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:13:14,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:14,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:15,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:16,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:17,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:18,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:19,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:20,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:20,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:21,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:22,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:23,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:24,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:25,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:25,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:26,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:27,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:28,941 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:13:28,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:29,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:13:29,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:13:29,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:30,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:30,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:31,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:32,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:33,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:34,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:35,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:36,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:36,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:37,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:38,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:39,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:40,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:41,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:41,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:42,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:43,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:44,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:13:44,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:13:44,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:45,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:46,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:46,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:47,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:48,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:49,949 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:50,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:51,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:52,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:52,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:53,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:54,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:55,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:56,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:57,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:13:57,950 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:58,943 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:13:58,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:13:59,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:13:59,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:13:59,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:00,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:01,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:02,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:02,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:03,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:04,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:05,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:06,951 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:07,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:08,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:08,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:09,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:10,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:11,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:12,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:13,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:14,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:14:14,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:14:14,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:14,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:15,953 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:16,953 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:17,953 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:18,953 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:19,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:19,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:14:19,914 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:14:19,914 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:14:19,916 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:14:19,953 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:20,656 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:14:20,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:21,658 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:14:21,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:22,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:23,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:24,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:25,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:25,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:26,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:27,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:28,944 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:14:28,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:29,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:14:29,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:14:29,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:30,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:30,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:31,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:32,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:33,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:34,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:35,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:36,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:36,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:37,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:38,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:39,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:40,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:41,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:41,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:42,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:43,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:44,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:14:44,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:14:44,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:45,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:46,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:46,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:47,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:48,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:49,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:50,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:51,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:52,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:52,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:53,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:54,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:55,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:56,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:57,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:58,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:14:58,946 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:14:58,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:14:59,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:14:59,428 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:14:59,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:00,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:01,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:02,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:03,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:03,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:04,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:05,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:06,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:07,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:08,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:09,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:09,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:10,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:11,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:12,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:13,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:14,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:15:14,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:15:14,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:14,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:15,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:16,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:17,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:18,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:19,962 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:20,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:20,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:21,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:22,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:23,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:24,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:25,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:26,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:26,963 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:27,964 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:28,948 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:15:28,964 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:29,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:15:29,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:15:29,964 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:31,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:31,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:32,056 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:33,056 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:33,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:15:33,530 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:15:33,530 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:15:33,533 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:15:33,837 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:15:34,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:35,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:35,840 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:15:36,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:37,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:37,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:38,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:39,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:40,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:41,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:42,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:43,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:43,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:44,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:44,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:15:44,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:15:45,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:46,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:47,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:48,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:48,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:49,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:50,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:51,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:52,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:53,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:54,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:54,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:15:55,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:56,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:57,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:58,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:58,950 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:15:59,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:15:59,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:15:59,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:15:59,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:00,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:01,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:02,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:03,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:04,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:05,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:05,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:06,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:07,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:08,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:09,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:10,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:10,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:11,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:12,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:13,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:14,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:14,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:16:14,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:16:15,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:15,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:16,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:17,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:18,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:19,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:20,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:21,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:21,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:22,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:23,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:24,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:25,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:26,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:27,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:27,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:28,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:28,951 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:16:29,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:29,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:16:29,429 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:16:30,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:31,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:32,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:32,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:33,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:34,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:35,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:36,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:37,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:38,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:38,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:39,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:40,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:41,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:42,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:43,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:44,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:44,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:16:44,430 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:16:44,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:45,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:46,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:47,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:48,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:16:48,017 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:16:48,017 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:16:48,019 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:16:48,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:48,988 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:16:49,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:49,991 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:16:50,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:50,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:51,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:52,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:53,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:54,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:55,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:55,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:16:56,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:57,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:58,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:58,953 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:16:59,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:16:59,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:16:59,430 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:17:00,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:00,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:01,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:02,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:03,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:04,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:05,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:06,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:06,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:07,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:08,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:09,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:10,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:11,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:11,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:12,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:13,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:14,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:14,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:17:14,430 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:17:15,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:16,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:16,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:17,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:18,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:19,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:20,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:21,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:22,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:22,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:23,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:24,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:25,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:26,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:27,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:27,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:28,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:28,955 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:17:29,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:29,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:17:29,430 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:17:30,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:31,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:32,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:32,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:33,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:34,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:35,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:36,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:37,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:38,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:38,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:39,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:40,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:41,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:42,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:43,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:44,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:44,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:17:44,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:17:44,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:45,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:46,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:47,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:48,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:49,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:50,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:50,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:51,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:52,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:53,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:54,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:55,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:56,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:56,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:17:57,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:58,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:58,956 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:17:59,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:17:59,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:17:59,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:18:00,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:01,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:01,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:02,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:03,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:04,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:04,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:18:04,561 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:18:04,561 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:18:04,562 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:18:05,150 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:18:05,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:06,154 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:18:06,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:06,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:07,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:08,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:09,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:10,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:11,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:12,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:12,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:13,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:14,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:18:14,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:18:14,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:15,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:16,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:17,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:17,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:18,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:19,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:20,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:21,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:22,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:23,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:23,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:24,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:25,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:26,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:27,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:28,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:28,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:28,959 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:18:29,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:18:29,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:18:29,531 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:30,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:31,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:32,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:33,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:33,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:34,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:35,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:36,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:37,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:38,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:39,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:39,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:40,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:41,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:42,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:43,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:44,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:18:44,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:18:44,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:44,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:45,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:46,533 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:47,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:48,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:49,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:50,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:50,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:51,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:52,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:53,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:54,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:55,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:18:55,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:56,534 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:57,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:58,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:18:58,961 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:18:59,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:18:59,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:18:59,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:00,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:00,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:01,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:02,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:03,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:04,535 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:05,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:06,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:06,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:07,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:08,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:09,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:10,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:11,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:11,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:12,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:13,537 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:14,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:19:14,432 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:19:14,536 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:15,537 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:16,537 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:16,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:17,537 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:18,537 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:19,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:19:19,101 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:19:19,101 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:19:19,102 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:19:19,309 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:19:19,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:20,310 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:19:20,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:21,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:21,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:22,314 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:19:22,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:23,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:24,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:25,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:26,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:27,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:27,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:28,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:28,963 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:19:29,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:19:29,432 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:19:29,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:30,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:31,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:32,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:32,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:33,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:34,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:35,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:36,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:37,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:37,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:38,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:39,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:40,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:41,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:42,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:42,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:43,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:44,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:19:44,432 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:19:44,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:45,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:46,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:47,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:48,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:48,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:49,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:50,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:51,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:52,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:53,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:53,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:54,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:55,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:56,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:57,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:58,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:19:58,965 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:19:58,966 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:19:59,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:19:59,432 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:19:59,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:00,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:01,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:02,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:03,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:04,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:04,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:05,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:06,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:07,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:08,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:09,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:09,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:10,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:11,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:12,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:13,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:14,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:20:14,433 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:20:14,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:15,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:15,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:16,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:17,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:18,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:19,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:20,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:20,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:21,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:22,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:23,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:24,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:25,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:25,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:26,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:27,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:28,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:28,967 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:20:29,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:20:29,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:20:29,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:30,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:30,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:31,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:32,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:20:32,222 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:20:32,222 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:20:32,224 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:20:32,461 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:20:32,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:33,696 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:34,464 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:20:34,696 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:35,696 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:36,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:36,696 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:37,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:38,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:39,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:40,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:41,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:42,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:42,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:43,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:44,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:20:44,632 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:20:44,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:45,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:46,697 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:47,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:47,798 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:48,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:49,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:50,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:51,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:52,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:53,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:53,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:54,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:55,698 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:56,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:57,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:58,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:20:58,969 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:20:58,972 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:20:59,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:20:59,632 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:20:59,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:00,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:01,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:02,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:03,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:04,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:04,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:05,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:06,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:07,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:08,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:09,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:09,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:10,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:11,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:12,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:13,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:14,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:21:14,632 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:21:14,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:14,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:15,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:16,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:17,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:18,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:19,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:20,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:20,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:21,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:22,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:23,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:24,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:25,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:26,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:26,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:27,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:28,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:28,971 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:21:29,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:21:29,632 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:21:29,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:30,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:31,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:31,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:32,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:33,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:34,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:35,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:36,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:37,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:37,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:38,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:39,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:40,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:41,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:42,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:43,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:43,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:43,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:21:43,781 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:21:43,781 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:21:43,783 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:21:44,620 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:21:44,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:21:44,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:21:44,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:45,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:46,624 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:21:46,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:47,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:48,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:48,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:49,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:50,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:51,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:52,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:53,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:54,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:21:54,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:55,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:56,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:57,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:58,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:58,972 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:21:59,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:21:59,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:21:59,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:21:59,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:00,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:01,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:02,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:03,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:04,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:05,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:05,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:06,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:07,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:08,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:09,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:10,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:11,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:11,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:12,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:13,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:14,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:22:14,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:22:14,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:15,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:16,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:16,799 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:17,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:18,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:19,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:20,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:21,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:22,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:22,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:23,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:24,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:25,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:26,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:27,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:27,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:28,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:28,974 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:22:29,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:22:29,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:22:29,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:30,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:31,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:32,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:32,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:33,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:34,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:35,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:36,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:37,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:38,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:38,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:39,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:40,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:41,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:42,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:43,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:43,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:44,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:22:44,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:22:44,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:45,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:46,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:47,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:48,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:48,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:49,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:50,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:51,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:52,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:53,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:54,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:54,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:55,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:22:55,209 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:22:55,209 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:22:55,211 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:22:55,777 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:22:55,777 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:22:55,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:56,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:57,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:58,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:22:58,976 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:22:59,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:22:59,633 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:22:59,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:22:59,822 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:00,823 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:01,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:02,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:03,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:04,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:05,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:05,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:06,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:07,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:08,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:09,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:10,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:11,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:11,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:12,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:13,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:14,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:23:14,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:23:14,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:15,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:16,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:16,825 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:17,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:18,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:19,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:20,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:21,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:22,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:22,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:23,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:24,826 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:25,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:26,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:27,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:28,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:28,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:28,977 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:23:29,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:23:29,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:23:29,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:30,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:31,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:32,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:33,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:33,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:34,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:35,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:36,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:37,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:38,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:39,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:39,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:40,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:41,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:42,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:43,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:44,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:23:44,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:23:44,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:44,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:45,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:46,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:47,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:48,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:49,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:50,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:50,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:51,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:52,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:53,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:54,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:55,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:23:55,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:56,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:57,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:58,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:23:58,980 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:23:59,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:23:59,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:23:59,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:00,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:00,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:01,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:02,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:03,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:04,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:05,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:06,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:06,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:07,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:24:07,062 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:24:07,062 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:24:07,064 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:24:07,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:07,924 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:24:07,924 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:24:08,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:09,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:10,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:11,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:12,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:12,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:13,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:14,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:24:14,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:24:14,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:15,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:16,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:17,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:17,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:18,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:19,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:20,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:21,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:22,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:23,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:23,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:24,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:25,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:26,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:27,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:28,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:28,981 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:24:28,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:29,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:24:29,634 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:24:29,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:30,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:31,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:32,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:33,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:34,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:34,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:35,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:36,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:37,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:38,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:39,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:39,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:40,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:41,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:42,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:43,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:44,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:24:44,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:24:44,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:44,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:45,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:46,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:47,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:48,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:49,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:50,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:50,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:51,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:52,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:53,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:54,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:55,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:56,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:24:56,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:57,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:58,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:24:58,982 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:24:59,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:24:59,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:24:59,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:00,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:01,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:02,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:02,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:03,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:04,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:05,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:06,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:07,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:07,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:08,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:09,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:10,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:11,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:12,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:12,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:13,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:14,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:25:14,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:25:14,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:15,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:16,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:17,801 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:17,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:18,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:25:18,557 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:25:18,557 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:25:18,559 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:25:18,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:19,056 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:25:19,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:20,057 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:25:20,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:21,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:22,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:23,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:23,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:24,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:25,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:26,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:27,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:28,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:28,983 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:25:28,984 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:29,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:25:29,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:25:29,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:30,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:31,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:32,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:33,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:34,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:34,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:35,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:36,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:37,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:38,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:39,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:39,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:40,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:41,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:42,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:43,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:44,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:25:44,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:25:44,800 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:44,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:45,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:46,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:47,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:48,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:49,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:50,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:50,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:51,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:52,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:53,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:54,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:55,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:56,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:25:56,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:57,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:58,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:25:58,986 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:25:59,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:25:59,635 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:25:59,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:00,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:01,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:01,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:02,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:03,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:04,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:05,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:06,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:07,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:07,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:08,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:09,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:10,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:11,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:12,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:12,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:13,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:14,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:26:14,636 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:26:14,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:15,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:16,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:17,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:17,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:18,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:19,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:20,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:21,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:22,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:23,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:23,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:24,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:25,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:26,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:27,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:28,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:28,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:28,986 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:26:29,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:26:29,636 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:26:29,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:30,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:26:30,161 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:26:30,161 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:26:30,165 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:26:30,194 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:26:30,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:31,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:32,198 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:26:32,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:33,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:34,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:34,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:35,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:36,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:37,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:38,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:39,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:39,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:40,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:41,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:42,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:43,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:44,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:26:44,636 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:26:44,802 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:44,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:45,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:46,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:47,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:48,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:49,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:50,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:50,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:51,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:52,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:53,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:54,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:55,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:26:55,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:56,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:57,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:58,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:26:58,988 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:26:59,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:26:59,636 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:26:59,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:00,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:00,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:01,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:02,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:03,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:04,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:05,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:06,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:06,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:07,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:08,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:09,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:10,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:11,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:11,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:12,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:13,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:14,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:27:14,636 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:27:14,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:15,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:16,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:16,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:17,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:18,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:19,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:20,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:21,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:22,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:22,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:23,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:24,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:25,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:26,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:27,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:28,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:28,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:28,989 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:27:29,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:27:29,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:27:29,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:30,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:31,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:32,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:33,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:33,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:34,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:35,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:36,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:37,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:38,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:39,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:39,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:40,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:41,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:27:41,774 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:27:41,774 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:27:41,776 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:27:41,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:42,335 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:27:42,335 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:27:42,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:43,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:44,339 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:27:44,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:27:44,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:27:44,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:44,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:45,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:46,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:47,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:48,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:49,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:50,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:50,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:51,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:52,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:53,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:54,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:55,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:27:55,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:56,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:57,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:58,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:27:58,991 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:27:59,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:27:59,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:27:59,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:00,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:00,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:01,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:02,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:03,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:04,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:05,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:06,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:06,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:07,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:08,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:09,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:10,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:11,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:11,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:12,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:13,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:14,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:28:14,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:28:14,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:15,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:16,803 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:16,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:17,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:18,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:19,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:20,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:21,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:22,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:22,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:23,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:24,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:25,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:26,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:27,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:27,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:28,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:28,993 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:28:29,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:28:29,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:28:29,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:30,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:31,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:32,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:32,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:33,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:34,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:35,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:36,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:37,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:38,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:38,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:39,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:40,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:41,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:42,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:43,779 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:43,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:44,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:28:44,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:28:44,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:45,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:46,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:47,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:48,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:48,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:49,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:50,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:51,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:52,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:53,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:53,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:54,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:28:54,025 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:28:54,025 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:28:54,026 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:28:54,471 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:28:54,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:55,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:56,474 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:28:56,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:57,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:58,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:28:58,995 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:28:58,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:28:59,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:28:59,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:28:59,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:00,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:01,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:02,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:03,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:04,779 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:04,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:05,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:06,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:07,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:08,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:09,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:09,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:10,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:11,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:12,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:13,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:14,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:29:14,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:29:14,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:14,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:15,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:16,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:17,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:18,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:19,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:20,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:20,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:21,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:22,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:23,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:24,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:25,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:25,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:26,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:27,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:28,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:28,997 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:29:29,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:29:29,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:29:29,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:30,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:30,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:31,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:32,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:33,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:34,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:35,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:36,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:36,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:37,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:38,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:39,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:40,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:41,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:42,781 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:42,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:43,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:44,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:29:44,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:29:44,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:45,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:46,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:47,804 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:47,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:48,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:49,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:50,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:51,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:52,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:53,781 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:53,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:54,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:55,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:56,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:57,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:58,781 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:29:58,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:29:58,998 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:29:59,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:29:59,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:29:59,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:00,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:01,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:02,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:03,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:03,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:04,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:05,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:06,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:30:06,269 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:30:06,269 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:30:06,271 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:30:06,634 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:30:06,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:07,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:08,639 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:30:08,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:09,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:09,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:10,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:11,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:12,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:13,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:14,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:30:14,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:30:14,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:14,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:15,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:16,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:17,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:18,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:19,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:20,781 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:20,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:21,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:22,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:23,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:24,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:25,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:25,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:26,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:27,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:28,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:29,000 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:30:29,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:30:29,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:30:29,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:30,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:30,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:31,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:32,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:33,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:34,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:35,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:36,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:36,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:37,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:38,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:39,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:40,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:41,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:42,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:42,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:43,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:44,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:30:44,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:30:44,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:45,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:46,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:47,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:47,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:48,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:49,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:50,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:51,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:52,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:53,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:53,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:54,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:55,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:56,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:57,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:58,783 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:30:58,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:30:59,001 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:30:59,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:30:59,639 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:30:59,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:00,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:01,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:02,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:03,806 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:03,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:04,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:05,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:06,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:07,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:08,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:09,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:09,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:10,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:11,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:12,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:13,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:14,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:31:14,639 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:31:14,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:14,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:15,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:16,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:17,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:31:17,645 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:31:17,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:31:17,647 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:31:17,776 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:31:18,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:18,778 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:31:19,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:20,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:20,783 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:21,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:22,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:23,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:24,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:25,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:25,783 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:26,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:27,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:28,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:29,003 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:31:29,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:29,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:31:29,639 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:31:30,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:30,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:31,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:32,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:33,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:34,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:35,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:36,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:36,783 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:37,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:38,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:39,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:40,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:41,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:42,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:42,783 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:43,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:44,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:44,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:31:44,639 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:31:45,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:46,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:47,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:47,806 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:48,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:49,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:50,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:51,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:52,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:53,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:53,784 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:54,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:55,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:56,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:57,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:58,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:58,784 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:31:59,005 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:31:59,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:31:59,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:31:59,639 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:32:00,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:01,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:02,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:03,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:03,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:04,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:05,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:06,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:07,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:08,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:09,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:09,784 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:10,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:11,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:12,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:13,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:14,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:14,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:32:14,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:32:14,805 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:15,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:16,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:17,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:18,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:19,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:20,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:20,784 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:21,084 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:22,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:23,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:24,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:25,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:26,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:26,786 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:27,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:28,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:29,007 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:32:29,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:29,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:32:29,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:32:30,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:30,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:32:30,350 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:32:30,350 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:32:30,351 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:32:30,916 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:32:31,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:32,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:32,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:32,920 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:32:33,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:34,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:35,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:36,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:37,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:37,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:38,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:39,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:40,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:41,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:42,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:42,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:43,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:44,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:44,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:32:44,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:32:45,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:46,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:47,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:47,806 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:48,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:49,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:50,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:51,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:52,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:53,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:53,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:54,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:55,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:56,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:57,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:58,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:59,009 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:32:59,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:32:59,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:32:59,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:32:59,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:33:00,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:01,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:02,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:03,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:04,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:04,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:05,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:06,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:07,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:08,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:09,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:09,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:10,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:11,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:12,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:13,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:14,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:14,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:33:14,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:33:14,806 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:15,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:16,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:17,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:18,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:19,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:20,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:20,785 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:21,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:22,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:23,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:24,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:25,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:25,786 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:26,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:27,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:28,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:29,010 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:33:29,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:29,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:33:29,640 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:33:30,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:30,808 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:31,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:32,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:33,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:34,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:35,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:36,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:36,787 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:37,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:38,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:39,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:40,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:41,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:41,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:42,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:42,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:33:42,233 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:33:42,234 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:33:42,236 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:33:43,080 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:33:43,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:44,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:44,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:33:44,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:33:45,085 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:33:45,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:46,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:47,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:47,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:48,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:49,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:50,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:51,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:52,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:53,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:53,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:54,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:55,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:56,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:57,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:58,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:58,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:33:59,011 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:33:59,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:33:59,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:33:59,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:34:00,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:01,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:02,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:03,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:04,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:04,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:05,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:06,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:07,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:08,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:09,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:10,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:10,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:11,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:12,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:13,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:14,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:14,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:34:14,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:34:15,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:16,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:16,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:17,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:18,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:19,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:20,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:21,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:21,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:22,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:23,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:24,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:25,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:26,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:27,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:27,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:28,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:29,013 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:34:29,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:29,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:34:29,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:34:30,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:31,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:32,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:32,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:33,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:34,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:35,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:36,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:37,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:38,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:38,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:39,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:40,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:41,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:42,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:43,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:43,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:44,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:44,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:34:44,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:34:45,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:46,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:47,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:48,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:48,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:49,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:50,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:51,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:52,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:53,552 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:53,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:54,552 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:55,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:34:55,353 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:34:55,353 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:34:55,355 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:34:55,552 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:56,223 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:34:56,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:57,225 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:34:57,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:58,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:59,014 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:34:59,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:34:59,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:34:59,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:34:59,641 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:35:00,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:01,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:02,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:03,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:04,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:04,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:05,553 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:06,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:07,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:08,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:09,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:09,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:10,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:11,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:12,555 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:13,554 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:14,555 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:14,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:35:14,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:35:15,555 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:15,846 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:16,555 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:17,555 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:18,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:19,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:20,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:20,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:21,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:22,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:23,556 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:24,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:25,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:26,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:26,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:27,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:28,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:29,016 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:35:29,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:29,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:35:29,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:35:30,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:31,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:32,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:32,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:33,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:34,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:35,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:36,559 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:37,558 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:37,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:38,559 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:39,559 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:40,559 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:41,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:42,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:42,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:43,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:44,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:44,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:35:44,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:35:45,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:46,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:47,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:48,560 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:48,847 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:49,561 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:50,561 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:51,561 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:52,561 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:53,561 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:53,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:54,562 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:55,562 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:56,562 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:57,562 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:58,562 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:58,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:35:59,018 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:35:59,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:35:59,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:35:59,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:36:00,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:01,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:02,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:03,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:04,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:04,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:05,563 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:06,564 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:07,564 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:08,564 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:08,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:36:08,821 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:36:08,821 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:36:08,823 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:36:09,358 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:36:09,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:09,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:10,360 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:36:10,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:11,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:12,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:13,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:14,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:14,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:36:14,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:36:15,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:15,848 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:16,565 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:17,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:18,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:19,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:20,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:20,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:21,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:22,566 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:23,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:24,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:25,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:25,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:26,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:27,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:28,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:29,020 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:36:29,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:29,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:36:29,643 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:36:30,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:31,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:31,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:32,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:33,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:34,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:35,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:36,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:37,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:37,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:38,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:39,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:40,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:41,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:42,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:43,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:43,849 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:44,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:44,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:36:44,642 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:36:45,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:46,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:47,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:48,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:48,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:49,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:50,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:51,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:52,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:53,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:53,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:54,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:55,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:56,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:57,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:58,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:59,021 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:36:59,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:36:59,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:36:59,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:36:59,643 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:37:00,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:01,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:02,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:03,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:04,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:04,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:05,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:06,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:07,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:08,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:09,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:10,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:10,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:11,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:12,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:13,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:14,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:14,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:37:14,643 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:37:15,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:16,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:16,850 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:17,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:18,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:19,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:20,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:21,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:21,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:22,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:37:22,385 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:37:22,385 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:37:22,387 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:37:22,515 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:37:22,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:23,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:24,518 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:37:24,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:25,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:26,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:27,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:27,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:28,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:29,023 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:37:29,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:37:29,643 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:37:29,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:30,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:31,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:32,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:33,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:33,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:34,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:35,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:36,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:37,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:38,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:38,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:39,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:40,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:41,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:42,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:43,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:43,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:44,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:37:44,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:37:44,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:45,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:46,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:47,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:48,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:48,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:49,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:50,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:51,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:52,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:53,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:54,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:54,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:37:55,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:56,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:57,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:58,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:59,024 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:37:59,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:37:59,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:37:59,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:37:59,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:00,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:01,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:02,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:03,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:04,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:04,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:05,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:06,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:07,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:08,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:09,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:09,851 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:10,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:11,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:12,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:13,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:14,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:38:14,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:38:14,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:14,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:15,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:16,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:17,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:18,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:19,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:20,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:20,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:21,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:22,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:23,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:24,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:25,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:25,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:26,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:27,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:28,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:29,027 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:38:29,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:38:29,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:38:29,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:30,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:31,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:31,852 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:32,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:33,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:34,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:35,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:36,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:38:36,605 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:38:36,605 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:38:36,607 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:38:36,670 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:38:36,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:37,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:37,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:38,674 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:38:38,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:39,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:40,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:41,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:42,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:42,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:43,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:44,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:38:44,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:38:44,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:45,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:46,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:47,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:47,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:48,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:49,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:50,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:51,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:52,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:53,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:53,853 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:54,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:55,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:56,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:57,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:58,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:38:58,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:38:59,029 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:38:59,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:38:59,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:38:59,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:00,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:01,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:02,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:03,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:04,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:04,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:05,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:06,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:07,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:08,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:09,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:10,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:10,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:11,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:12,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:13,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:14,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:39:14,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:39:14,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:15,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:15,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:16,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:17,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:18,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:19,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:20,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:20,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:21,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:22,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:23,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:24,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:25,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:26,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:26,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:27,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:28,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:29,030 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:39:29,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:39:29,644 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:39:29,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:30,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:31,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:32,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:32,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:33,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:34,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:35,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:36,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:37,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:37,854 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:38,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:39,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:40,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:41,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:42,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:42,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:43,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:44,645 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:39:44,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:39:44,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:45,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:46,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:47,755 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:48,754 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:48,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:49,754 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:50,284 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:39:50,285 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:39:50,286 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:39:50,287 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:39:50,837 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:39:51,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:52,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:52,841 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:39:53,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:54,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:54,288 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:39:55,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:56,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:57,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:58,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:59,033 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:39:59,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:39:59,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:39:59,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:39:59,810 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:00,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:01,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:02,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:03,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:04,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:04,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:05,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:06,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:07,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:08,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:09,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:09,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:10,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:11,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:12,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:13,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:14,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:14,645 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:40:14,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:40:14,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:15,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:16,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:17,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:18,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:19,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:19,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:20,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:21,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:22,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:23,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:24,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:24,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:25,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:26,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:27,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:28,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:29,034 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:40:29,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:29,645 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:40:29,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:40:29,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:30,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:31,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:32,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:33,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:34,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:34,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:35,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:36,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:37,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:38,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:39,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:39,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:40,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:41,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:42,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:43,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:44,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:44,645 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:40:44,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:40:44,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:45,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:46,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:47,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:48,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:49,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:49,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:50,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:51,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:52,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:53,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:54,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:54,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:40:55,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:56,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:57,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:58,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:59,036 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:40:59,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:40:59,645 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:40:59,645 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:40:59,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:00,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:01,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:02,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:03,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:41:03,097 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:41:03,097 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:41:03,099 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:41:03,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:03,978 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:41:04,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:04,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:04,980 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:41:05,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:06,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:07,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:08,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:09,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:10,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:10,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:11,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:12,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:13,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:14,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:14,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:41:14,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:41:15,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:16,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:16,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:17,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:18,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:19,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:20,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:21,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:21,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:22,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:23,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:24,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:25,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:26,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:26,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:27,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:28,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:29,037 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:41:29,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:29,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:41:29,646 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:41:30,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:31,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:32,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:32,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:33,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:34,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:35,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:36,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:37,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:37,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:38,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:39,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:40,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:41,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:42,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:43,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:43,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:44,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:44,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:41:44,646 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:41:45,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:46,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:47,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:48,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:49,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:49,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:50,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:51,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:52,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:53,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:54,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:54,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:41:55,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:56,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:57,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:58,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:59,040 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:41:59,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:41:59,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:41:59,646 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:42:00,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:00,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:01,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:02,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:03,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:04,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:05,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:05,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:06,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:07,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:08,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:09,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:10,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:10,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:11,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:12,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:13,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:14,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:14,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:42:14,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:42:15,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:16,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:16,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:16,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:42:16,353 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:42:16,353 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:42:16,355 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:42:17,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:17,123 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:42:17,123 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:42:18,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:19,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:20,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:21,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:21,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:22,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:23,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:24,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:25,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:26,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:26,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:27,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:28,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:29,041 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:42:29,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:29,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:42:29,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:42:30,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:31,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:32,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:32,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:33,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:34,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:35,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:36,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:37,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:38,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:38,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:39,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:40,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:41,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:42,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:43,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:43,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:44,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:44,646 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:42:44,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:42:45,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:46,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:47,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:48,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:48,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:49,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:50,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:51,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:52,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:53,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:54,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:54,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:42:55,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:56,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:57,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:58,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:59,042 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:42:59,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:42:59,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:42:59,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:42:59,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:00,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:01,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:02,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:03,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:04,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:04,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:05,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:06,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:07,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:08,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:09,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:09,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:10,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:11,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:12,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:13,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:14,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:14,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:43:14,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:43:14,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:15,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:16,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:17,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:18,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:19,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:20,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:20,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:21,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:22,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:23,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:24,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:25,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:26,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:26,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:27,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:28,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:43:28,041 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:43:28,041 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:43:28,043 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:43:28,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:28,261 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:43:29,053 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:43:29,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:29,263 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:43:29,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:43:29,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:43:30,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:31,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:31,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:32,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:33,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:34,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:35,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:36,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:36,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:37,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:38,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:39,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:40,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:41,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:41,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:42,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:43,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:44,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:44,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:43:44,647 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:43:45,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:46,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:46,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:47,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:48,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:49,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:50,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:51,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:51,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:52,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:53,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:54,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:55,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:56,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:57,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:57,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:43:58,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:59,046 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:43:59,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:43:59,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:43:59,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:44:00,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:01,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:02,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:02,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:03,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:04,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:05,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:06,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:07,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:08,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:08,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:09,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:10,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:11,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:12,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:13,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:13,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:14,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:14,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:44:14,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:44:15,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:16,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:17,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:18,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:19,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:19,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:20,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:21,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:22,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:23,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:24,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:24,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:25,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:26,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:27,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:28,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:29,049 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:44:29,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:29,647 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:44:29,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:44:30,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:30,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:31,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:32,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:33,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:34,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:35,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:35,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:36,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:37,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:38,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:39,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:40,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:40,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:44:40,189 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:44:40,189 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:44:40,191 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:44:40,425 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:44:41,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:41,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:41,427 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:44:42,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:43,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:44,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:44,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:44:44,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:44:45,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:46,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:46,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:47,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:48,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:49,129 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:50,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:51,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:51,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:52,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:53,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:54,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:55,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:56,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:56,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:44:57,130 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:58,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:59,051 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:44:59,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:44:59,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:44:59,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:45:00,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:01,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:02,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:02,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:03,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:04,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:05,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:06,131 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:07,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:07,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:08,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:09,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:10,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:11,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:12,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:12,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:13,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:14,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:14,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:45:14,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:45:15,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:16,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:17,132 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:18,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:18,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:19,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:20,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:21,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:22,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:23,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:23,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:24,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:25,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:26,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:27,133 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:28,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:29,051 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:45:29,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:29,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:29,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:45:29,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:45:30,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:31,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:32,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:33,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:34,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:34,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:35,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:36,134 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:37,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:38,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:39,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:39,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:40,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:41,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:42,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:43,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:44,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:44,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:45:44,648 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:45:45,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:45,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:46,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:47,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:48,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:49,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:50,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:50,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:51,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:52,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:45:52,037 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:45:52,037 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:45:52,040 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:45:52,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:52,567 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:45:53,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:53,568 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:45:54,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:55,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:55,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:45:56,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:57,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:58,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:59,053 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:45:59,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:45:59,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:45:59,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:46:00,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:01,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:01,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:02,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:03,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:04,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:05,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:06,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:06,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:07,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:08,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:09,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:10,138 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:11,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:11,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:12,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:13,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:14,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:14,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:46:14,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:46:15,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:16,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:17,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:17,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:18,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:19,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:20,139 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:21,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:22,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:22,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:23,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:24,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:25,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:26,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:27,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:28,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:28,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:29,057 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:46:29,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:29,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:46:29,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:46:30,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:31,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:32,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:33,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:34,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:34,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:35,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:36,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:37,141 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:38,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:39,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:39,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:40,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:41,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:42,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:43,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:44,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:44,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:46:44,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:46:45,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:45,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:46,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:47,142 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:48,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:49,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:50,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:50,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:51,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:52,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:53,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:54,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:55,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:56,143 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:56,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:46:57,144 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:58,144 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:59,058 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:46:59,144 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:46:59,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:46:59,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:47:00,144 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:01,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:02,299 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:02,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:03,299 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:03,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:47:03,669 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:47:03,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:47:03,671 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:47:03,716 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:47:04,299 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:05,299 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:05,722 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:47:06,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:07,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:07,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:08,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:09,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:10,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:11,300 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:12,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:13,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:13,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:14,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:14,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:47:14,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:47:15,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:16,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:17,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:18,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:19,301 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:19,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:20,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:21,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:22,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:23,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:24,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:24,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:25,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:26,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:27,302 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:28,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:29,060 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:47:29,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:29,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:47:29,649 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:47:30,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:30,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:31,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:32,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:33,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:34,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:35,303 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:35,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:36,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:37,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:38,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:39,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:40,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:40,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:41,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:42,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:43,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:44,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:44,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:47:44,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:47:45,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:46,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:46,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:47,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:48,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:49,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:50,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:51,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:51,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:52,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:53,305 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:54,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:55,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:56,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:57,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:57,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:47:58,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:59,061 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:47:59,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:47:59,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:47:59,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:48:00,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:01,306 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:02,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:03,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:03,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:04,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:05,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:06,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:07,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:08,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:08,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:09,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:10,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:11,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:12,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:13,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:14,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:14,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:48:14,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:48:14,816 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:15,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:16,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:17,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:48:17,121 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:48:17,121 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:48:17,123 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:48:17,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:17,853 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:48:18,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:18,855 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:48:19,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:19,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:20,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:21,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:22,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:23,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:24,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:25,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:25,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:26,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:27,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:28,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:29,063 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:48:29,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:29,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:48:29,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:48:30,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:31,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:31,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:32,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:33,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:34,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:35,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:36,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:36,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:37,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:38,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:39,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:40,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:41,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:42,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:42,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:43,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:44,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:44,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:48:44,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:48:45,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:46,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:47,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:48,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:48,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:49,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:50,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:51,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:52,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:53,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:53,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:54,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:55,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:56,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:57,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:58,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:58,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:48:59,064 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:48:59,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:48:59,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:48:59,650 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:49:00,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:01,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:02,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:03,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:04,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:04,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:05,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:06,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:07,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:08,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:09,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:10,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:10,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:11,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:12,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:13,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:14,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:14,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:49:14,651 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:49:15,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:16,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:16,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:17,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:18,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:19,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:20,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:21,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:21,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:22,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:23,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:24,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:25,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:26,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:27,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:27,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:28,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:29,066 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:49:29,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:29,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:49:29,651 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:49:29,779 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:49:29,816 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:49:29,817 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:49:29,819 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:49:30,010 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:49:30,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:31,012 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:49:31,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:32,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:33,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:33,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:34,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:35,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:36,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:37,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:38,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:38,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:39,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:40,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:41,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:42,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:43,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:44,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:44,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:44,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:49:44,651 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:49:45,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:46,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:47,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:48,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:49,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:49,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:50,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:51,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:52,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:53,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:54,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:55,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:55,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:49:56,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:57,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:58,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:59,068 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:49:59,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:49:59,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:49:59,651 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:50:00,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:01,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:01,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:02,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:03,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:04,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:05,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:06,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:07,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:07,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:08,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:09,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:10,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:11,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:12,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:12,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:13,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:14,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:14,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:50:14,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:50:15,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:16,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:17,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:18,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:18,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:19,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:20,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:21,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:22,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:23,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:23,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:24,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:25,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:26,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:27,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:28,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:29,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:29,070 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:50:29,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:29,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:50:29,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:50:30,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:31,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:32,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:33,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:34,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:34,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:35,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:36,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:37,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:38,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:39,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:40,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:40,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:41,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:42,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:42,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:50:42,845 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:50:42,845 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:50:42,847 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:50:43,148 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:50:43,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:44,377 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:44,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:50:44,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:50:45,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:45,151 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:50:45,377 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:46,377 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:47,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:48,377 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:49,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:50,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:51,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:51,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:52,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:53,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:54,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:55,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:56,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:57,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:50:57,378 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:58,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:59,071 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:50:59,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:50:59,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:50:59,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:51:00,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:01,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:02,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:03,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:03,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:04,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:05,379 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:06,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:07,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:08,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:08,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:09,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:10,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:11,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:12,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:13,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:13,380 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:14,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:14,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:51:14,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:51:15,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:16,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:17,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:18,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:18,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:19,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:20,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:21,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:22,381 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:23,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:24,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:24,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:25,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:26,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:27,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:28,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:29,073 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:51:29,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:29,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:29,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:51:29,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:51:30,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:31,382 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:32,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:33,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:34,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:35,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:35,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:36,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:37,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:38,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:39,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:40,383 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:41,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:41,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:42,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:43,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:44,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:44,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:51:44,652 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:51:45,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:46,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:47,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:47,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:48,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:49,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:50,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:51,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:52,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:52,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:53,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:54,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:55,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:56,136 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:51:56,137 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:51:56,138 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:51:56,140 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:51:56,304 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:51:56,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:57,140 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:51:57,305 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:51:57,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:58,385 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:59,075 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:51:59,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:51:59,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:51:59,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:52:00,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:01,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:02,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:03,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:03,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:04,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:05,386 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:06,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:07,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:08,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:08,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:09,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:10,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:11,387 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:12,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:13,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:14,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:14,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:14,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:52:14,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:52:15,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:16,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:17,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:18,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:19,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:19,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:20,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:21,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:22,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:23,389 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:24,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:24,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:25,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:26,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:27,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:28,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:29,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:29,076 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:52:29,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:29,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:52:29,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:52:30,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:31,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:32,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:33,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:34,390 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:35,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:35,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:36,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:37,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:38,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:39,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:40,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:40,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:41,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:42,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:43,391 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:44,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:44,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:52:44,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:52:45,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:46,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:46,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:47,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:48,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:49,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:50,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:51,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:51,392 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:52,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:53,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:54,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:55,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:56,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:52:56,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:57,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:58,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:59,078 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:52:59,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:52:59,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:52:59,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:53:00,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:01,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:01,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:02,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:03,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:04,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:05,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:06,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:07,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:07,394 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:08,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:08,684 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:53:08,685 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:53:08,685 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:53:08,687 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:53:09,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:09,448 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:53:09,449 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:53:10,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:11,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:11,452 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:53:12,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:12,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:13,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:14,395 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:14,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:53:14,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:53:15,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:16,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:17,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:17,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:18,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:19,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:20,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:21,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:22,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:22,396 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:23,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:24,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:25,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:26,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:27,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:28,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:28,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:29,079 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:53:29,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:29,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:53:29,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:53:30,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:31,397 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:32,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:33,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:34,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:34,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:35,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:36,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:37,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:38,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:39,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:39,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:40,398 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:41,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:42,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:43,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:44,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:44,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:44,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:53:44,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:53:45,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:46,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:47,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:48,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:49,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:49,399 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:50,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:51,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:52,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:53,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:54,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:54,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:55,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:56,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:57,400 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:58,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:59,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:53:59,082 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:53:59,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:53:59,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:53:59,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:54:00,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:01,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:02,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:03,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:04,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:04,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:05,401 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:06,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:07,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:08,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:09,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:09,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:10,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:11,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:12,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:13,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:14,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:14,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:54:14,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:54:14,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:15,402 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:16,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:17,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:18,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:19,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:20,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:20,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:21,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:54:21,161 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:54:21,161 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:54:21,163 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:54:21,403 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:21,605 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:54:22,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:23,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:23,609 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:54:24,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:25,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:25,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:26,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:27,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:28,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:29,084 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:54:29,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:29,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:54:29,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:54:30,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:31,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:31,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:32,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:33,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:34,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:35,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:36,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:36,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:37,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:38,405 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:39,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:40,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:41,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:42,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:42,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:43,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:44,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:44,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:54:44,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:54:45,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:46,406 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:47,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:47,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:48,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:49,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:50,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:51,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:52,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:52,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:53,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:54,407 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:55,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:56,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:57,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:58,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:54:58,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:59,085 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:54:59,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:54:59,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:54:59,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:55:00,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:01,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:02,408 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:03,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:04,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:04,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:05,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:06,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:07,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:08,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:09,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:09,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:10,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:11,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:12,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:13,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:14,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:14,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:55:14,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:55:14,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:15,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:16,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:17,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:18,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:19,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:20,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:20,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:21,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:22,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:23,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:24,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:25,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:25,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:26,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:27,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:28,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:29,088 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:55:29,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:29,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:55:29,654 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:55:30,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:31,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:31,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:32,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:33,292 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:55:33,293 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:55:33,293 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:55:33,295 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:55:33,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:33,745 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:55:34,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:35,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:35,749 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:55:36,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:36,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:37,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:38,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:39,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:40,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:41,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:42,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:42,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:43,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:44,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:44,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:55:44,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:55:45,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:46,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:47,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:47,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:48,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:49,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:50,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:51,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:52,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:53,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:53,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:54,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:55,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:56,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:57,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:58,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:55:58,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:59,089 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:55:59,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:55:59,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:55:59,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:56:00,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:01,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:02,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:03,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:04,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:04,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:05,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:06,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:07,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:08,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:09,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:09,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:10,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:11,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:12,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:13,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:14,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:14,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:56:14,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:56:14,821 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:15,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:16,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:17,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:18,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:19,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:20,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:20,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:21,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:22,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:23,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:24,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:25,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:26,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:26,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:27,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:28,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:29,090 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:56:29,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:29,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:56:29,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:56:30,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:31,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:32,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:32,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:33,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:34,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:35,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:36,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:37,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:38,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:38,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:39,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:40,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:41,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:42,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:43,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:43,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:44,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:44,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:56:44,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:56:45,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:45,808 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:56:45,809 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:56:45,809 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:56:45,812 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:56:45,886 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:56:46,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:47,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:47,890 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:56:48,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:48,812 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:49,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:50,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:51,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:52,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:53,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:54,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:54,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:55,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:56,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:57,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:58,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:59,093 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:56:59,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:56:59,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:56:59,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:56:59,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:57:00,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:01,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:02,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:03,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:04,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:05,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:05,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:06,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:07,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:08,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:09,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:10,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:11,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:11,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:12,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:13,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:14,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:14,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:57:14,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:57:15,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:16,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:16,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:17,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:18,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:19,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:20,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:21,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:21,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:22,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:23,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:24,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:25,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:26,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:27,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:27,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:28,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:29,093 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:57:29,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:29,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:57:29,655 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:57:30,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:31,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:32,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:33,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:33,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:34,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:35,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:36,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:37,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:38,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:38,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:39,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:40,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:41,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:42,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:43,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:43,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:44,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:44,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:57:44,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:57:45,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:46,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:47,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:48,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:48,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:49,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:50,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:51,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:52,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:53,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:54,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:54,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:55,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:56,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:57,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:58,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:57:58,129 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:57:58,130 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:57:58,131 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:57:58,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:59,028 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:57:59,095 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:57:59,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:57:59,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:57:59,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:57:59,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:58:00,030 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:58:00,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:01,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:02,427 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:03,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:04,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:05,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:05,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:06,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:07,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:08,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:09,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:10,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:11,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:11,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:12,428 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:13,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:14,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:14,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:58:14,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:58:15,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:16,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:16,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:17,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:18,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:19,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:20,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:21,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:22,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:22,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:23,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:24,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:25,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:26,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:27,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:27,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:28,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:29,096 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:58:29,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:29,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:58:29,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:58:30,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:31,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:32,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:32,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:33,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:34,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:35,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:36,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:37,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:37,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:38,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:39,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:40,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:41,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:42,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:43,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:43,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:44,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:44,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:58:44,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:58:45,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:46,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:47,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:48,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:49,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:49,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:50,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:51,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:52,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:53,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:54,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:54,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:55,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:56,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:57,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:58,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:59,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:58:59,099 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:58:59,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:58:59,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:58:59,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:59:00,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:01,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:02,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:03,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:04,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:04,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:05,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:06,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:07,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:08,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:09,014 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:09,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:10,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 22:59:10,109 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 22:59:10,109 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 22:59:10,111 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 22:59:10,148 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 22:59:10,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:11,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:12,151 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 22:59:12,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:13,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:14,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:14,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:14,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:59:14,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:59:15,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:16,624 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:17,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:18,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:19,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:20,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:20,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:21,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:22,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:23,625 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:24,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:25,014 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:25,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:26,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:27,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:28,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:29,099 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:59:29,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:29,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:59:29,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:59:30,014 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:30,626 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:31,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:32,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:33,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:34,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:35,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:36,014 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:36,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:37,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:38,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:39,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:40,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:41,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:41,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:42,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:43,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:44,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:44,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:59:44,656 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 22:59:45,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:46,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:47,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:47,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:48,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:49,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:50,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:51,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:52,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:52,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:53,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:54,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:55,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:56,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:57,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:58,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 22:59:58,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:59,102 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 22:59:59,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 22:59:59,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 22:59:59,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:00:00,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:01,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:02,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:03,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:03,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:04,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:05,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:06,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:07,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:08,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:08,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:09,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:10,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:11,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:12,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:13,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:14,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:14,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:14,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:00:14,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:00:15,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:16,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:17,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:18,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:19,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:19,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:20,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:21,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:21,988 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:00:21,989 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:00:21,989 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:00:21,996 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:00:22,286 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:00:22,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:23,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:24,290 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:00:24,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:24,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:25,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:26,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:27,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:28,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:29,104 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:00:29,648 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:29,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:00:29,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:00:30,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:30,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:31,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:32,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:33,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:34,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:35,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:35,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:36,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:37,649 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:38,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:39,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:40,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:41,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:41,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:42,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:43,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:44,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:44,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:00:44,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:00:45,650 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:46,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:46,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:47,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:48,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:49,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:50,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:51,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:52,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:52,651 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:53,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:54,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:55,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:56,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:57,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:00:57,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:58,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:59,105 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:00:59,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:00:59,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:00:59,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:01:00,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:01,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:02,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:02,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:03,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:04,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:05,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:06,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:07,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:07,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:08,653 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:09,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:10,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:11,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:12,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:13,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:13,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:14,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:14,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:01:14,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:01:15,654 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:16,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:17,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:18,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:18,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:19,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:20,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:21,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:22,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:23,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:24,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:24,655 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:25,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:26,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:27,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:28,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:29,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:29,106 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:01:29,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:29,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:01:29,657 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:01:30,656 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:31,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:32,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:33,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:34,030 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:34,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:01:34,073 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:01:34,074 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:01:34,075 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:01:34,436 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:01:34,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:35,438 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:01:35,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:36,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:37,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:38,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:39,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:40,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:40,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:41,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:42,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:43,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:44,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:01:44,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:01:44,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:45,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:45,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:46,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:47,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:48,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:49,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:50,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:50,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:51,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:52,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:53,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:54,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:55,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:56,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:01:56,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:57,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:58,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:01:59,108 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:01:59,657 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:01:59,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:01:59,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:00,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:01,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:01,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:02,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:03,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:04,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:05,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:06,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:06,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:07,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:08,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:09,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:10,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:11,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:11,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:12,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:13,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:14,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:02:14,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:02:14,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:15,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:16,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:17,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:17,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:18,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:19,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:20,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:21,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:22,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:23,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:23,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:24,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:25,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:26,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:27,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:28,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:28,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:29,111 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:02:29,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:02:29,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:02:29,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:30,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:31,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:32,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:33,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:34,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:34,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:35,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:36,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:37,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:38,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:39,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:39,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:40,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:41,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:42,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:43,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:44,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:02:44,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:02:44,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:44,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:45,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:02:45,461 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:02:45,461 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:02:45,463 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:02:45,578 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:02:45,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:46,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:47,590 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:02:47,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:48,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:49,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:50,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:50,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:51,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:52,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:53,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:54,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:55,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:56,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:02:56,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:57,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:58,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:02:59,111 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:02:59,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:02:59,658 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:02:59,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:00,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:01,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:01,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:02,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:03,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:04,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:05,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:06,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:07,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:07,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:08,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:09,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:10,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:11,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:12,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:12,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:13,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:14,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:03:14,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:03:14,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:15,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:16,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:17,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:17,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:18,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:19,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:20,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:21,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:22,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:22,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:23,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:24,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:25,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:26,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:27,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:27,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:28,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:29,113 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:03:29,658 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:03:29,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:03:29,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:30,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:31,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:32,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:32,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:33,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:34,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:35,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:36,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:37,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:38,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:38,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:39,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:40,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:41,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:42,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:43,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:43,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:44,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:03:44,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:03:44,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:45,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:46,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:47,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:48,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:49,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:49,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:50,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:51,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:52,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:53,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:54,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:54,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:55,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:56,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:57,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:58,148 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:03:58,150 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:03:58,150 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:03:58,152 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:03:58,733 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:03:58,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:03:59,114 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:03:59,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:03:59,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:03:59,660 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:03:59,735 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:03:59,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:00,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:01,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:02,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:03,855 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:04,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:05,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:05,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:06,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:07,856 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:08,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:09,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:10,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:10,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:11,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:12,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:13,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:14,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:04:14,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:04:14,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:15,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:16,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:16,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:17,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:18,857 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:19,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:20,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:21,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:21,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:22,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:23,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:24,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:25,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:26,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:27,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:27,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:28,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:29,115 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:04:29,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:04:29,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:04:29,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:30,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:31,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:32,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:32,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:33,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:34,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:35,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:36,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:37,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:38,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:38,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:39,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:40,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:41,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:42,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:43,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:44,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:44,659 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:04:44,659 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:04:44,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:45,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:46,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:47,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:48,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:49,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:49,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:50,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:51,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:52,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:53,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:54,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:54,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:55,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:56,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:57,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:58,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:04:59,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:04:59,118 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:04:59,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:04:59,660 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:04:59,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:00,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:01,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:02,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:03,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:04,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:04,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:05,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:06,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:07,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:08,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:09,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:10,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:10,540 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:05:10,541 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:05:10,542 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:05:10,543 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:05:10,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:10,876 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:05:11,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:11,879 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:05:12,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:13,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:14,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:05:14,660 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:05:14,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:15,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:16,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:16,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:17,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:18,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:19,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:20,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:21,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:22,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:22,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:23,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:24,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:25,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:26,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:27,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:27,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:28,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:29,119 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:05:29,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:05:29,660 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:05:29,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:30,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:31,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:32,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:33,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:33,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:34,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:35,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:36,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:37,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:38,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:38,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:39,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:40,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:41,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:42,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:43,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:43,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:44,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:05:44,660 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:05:44,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:45,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:46,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:47,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:48,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:49,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:49,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:50,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:51,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:52,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:53,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:54,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:54,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:55,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:56,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:57,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:58,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:05:59,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:05:59,120 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:05:59,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:05:59,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:05:59,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:00,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:01,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:02,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:03,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:04,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:04,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:05,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:06,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:07,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:08,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:09,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:10,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:10,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:11,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:12,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:13,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:14,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:06:14,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:06:14,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:15,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:16,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:16,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:17,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:18,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:19,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:20,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:21,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:21,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:22,768 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:06:22,769 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:06:22,770 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:06:22,771 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:06:22,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:23,027 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:06:23,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:24,029 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:06:24,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:25,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:26,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:26,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:27,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:28,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:29,122 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:06:29,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:06:29,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:06:29,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:30,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:31,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:31,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:32,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:33,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:34,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:35,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:36,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:37,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:37,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:38,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:39,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:40,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:41,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:42,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:43,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:43,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:44,660 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:06:44,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:06:44,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:45,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:46,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:47,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:48,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:48,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:49,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:50,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:51,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:52,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:53,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:53,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:54,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:55,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:56,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:57,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:58,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:06:58,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:06:59,124 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:06:59,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:06:59,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:06:59,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:00,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:01,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:02,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:03,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:04,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:04,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:05,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:06,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:07,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:08,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:09,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:09,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:10,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:11,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:12,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:13,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:14,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:07:14,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:07:14,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:14,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:15,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:16,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:17,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:18,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:19,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:20,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:20,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:21,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:22,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:23,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:24,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:25,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:25,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:26,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:27,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:28,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:29,128 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:07:29,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:07:29,661 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:07:29,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:30,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:30,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:31,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:32,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:33,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:34,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:35,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:35,916 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:07:35,917 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:35,918 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:07:35,918 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:07:35,920 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:07:36,171 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:07:36,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:37,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:38,174 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:07:38,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:39,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:40,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:41,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:41,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:42,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:43,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:44,661 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:07:44,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:07:44,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:45,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:46,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:46,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:47,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:48,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:49,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:50,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:51,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:52,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:52,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:53,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:54,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:55,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:56,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:57,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:07:57,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:58,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:07:59,129 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:07:59,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:07:59,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:07:59,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:00,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:01,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:02,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:02,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:03,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:04,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:05,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:06,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:07,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:07,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:08,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:09,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:10,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:11,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:12,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:13,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:13,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:14,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:08:14,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:08:14,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:15,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:16,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:17,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:18,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:19,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:19,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:20,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:21,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:22,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:23,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:24,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:24,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:25,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:26,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:27,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:28,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:29,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:29,130 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:08:29,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:08:29,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:08:29,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:30,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:31,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:32,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:33,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:34,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:34,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:35,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:36,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:37,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:38,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:39,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:40,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:40,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:41,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:42,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:43,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:44,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:08:44,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:08:44,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:45,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:46,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:46,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:47,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:48,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:08:48,257 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:08:48,257 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:08:48,259 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:08:48,314 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:08:48,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:49,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:50,318 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:08:50,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:51,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:51,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:52,992 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:53,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:54,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:55,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:56,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:08:56,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:57,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:58,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:08:59,132 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:08:59,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:08:59,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:08:59,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:00,993 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:01,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:02,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:02,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:03,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:04,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:05,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:06,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:07,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:07,994 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:08,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:09,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:10,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:11,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:12,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:12,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:13,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:14,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:09:14,662 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:09:14,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:15,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:16,995 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:17,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:18,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:18,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:19,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:20,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:21,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:22,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:23,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:23,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:24,996 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:25,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:26,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:27,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:28,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:28,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:29,133 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:09:29,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:09:29,663 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:09:29,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:30,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:31,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:32,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:33,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:33,997 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:34,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:35,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:36,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:37,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:38,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:39,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:39,998 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:40,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:41,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:42,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:43,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:44,662 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:09:44,663 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:09:44,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:44,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:45,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:46,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:47,999 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:49,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:50,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:50,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:51,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:52,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:53,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:54,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:55,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:55,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:09:56,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:57,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:58,000 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:59,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:09:59,136 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:09:59,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:09:59,663 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:10:00,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:00,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:01,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:01,364 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:10:01,365 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:10:01,365 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:10:01,367 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:10:01,458 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:10:02,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:02,459 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:10:03,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:04,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:05,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:05,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:06,001 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:07,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:08,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:09,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:10,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:11,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:11,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:12,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:13,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:14,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:14,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:10:14,663 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:10:15,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:16,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:17,002 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:17,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:18,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:19,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:20,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:21,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:22,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:23,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:23,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:24,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:25,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:26,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:27,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:28,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:28,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:29,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:29,139 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:10:29,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:10:29,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:10:30,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:31,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:32,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:33,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:33,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:34,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:35,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:36,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:37,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:38,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:39,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:39,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:40,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:41,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:42,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:43,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:44,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:44,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:44,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:10:44,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:10:45,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:46,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:47,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:48,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:49,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:50,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:50,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:51,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:52,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:53,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:54,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:55,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:56,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:56,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:10:57,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:58,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:59,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:10:59,141 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:10:59,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:10:59,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:11:00,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:01,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:02,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:02,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:03,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:04,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:05,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:06,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:07,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:07,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:08,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:09,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:10,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:11,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:12,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:13,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:13,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:13,544 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:11:13,545 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:11:13,545 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:11:13,546 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:11:13,593 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:11:14,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:14,595 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:11:14,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:11:14,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:11:15,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:16,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:16,599 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:11:17,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:18,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:18,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:19,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:20,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:21,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:22,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:23,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:24,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:24,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:25,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:26,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:27,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:28,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:29,142 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:11:29,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:29,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:29,663 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:11:29,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:11:30,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:31,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:32,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:33,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:34,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:35,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:35,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:36,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:37,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:38,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:39,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:40,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:41,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:41,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:42,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:43,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:44,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:44,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:11:44,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:11:45,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:46,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:47,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:47,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:48,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:49,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:50,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:51,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:52,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:52,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:53,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:54,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:55,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:56,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:57,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:58,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:11:58,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:59,144 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:11:59,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:11:59,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:11:59,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:12:00,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:01,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:02,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:03,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:03,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:04,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:05,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:06,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:07,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:08,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:08,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:09,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:10,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:11,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:12,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:13,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:14,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:14,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:14,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:12:14,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:12:15,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:16,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:17,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:18,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:19,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:19,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:20,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:21,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:22,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:23,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:24,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:25,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:25,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:25,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:12:25,466 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:12:25,466 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:12:25,468 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:12:25,795 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:12:26,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:26,796 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:12:27,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:28,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:29,146 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:12:29,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:29,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:12:29,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:12:30,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:31,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:31,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:32,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:33,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:34,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:35,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:36,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:36,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:37,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:38,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:39,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:40,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:41,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:42,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:42,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:43,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:44,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:44,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:12:44,664 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:12:45,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:46,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:47,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:48,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:48,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:49,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:50,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:51,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:52,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:53,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:53,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:54,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:55,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:56,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:57,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:58,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:12:58,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:59,148 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:12:59,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:12:59,664 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:12:59,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:13:00,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:01,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:02,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:03,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:04,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:04,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:05,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:06,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:07,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:08,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:09,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:09,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:10,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:11,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:12,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:13,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:14,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:14,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:13:14,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:13:14,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:15,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:16,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:17,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:18,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:19,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:20,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:20,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:21,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:22,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:23,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:24,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:25,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:25,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:26,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:27,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:28,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:29,150 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:13:29,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:29,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:13:29,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:13:30,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:30,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:31,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:32,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:33,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:34,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:35,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:35,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:36,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:37,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:37,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:13:37,605 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:13:37,605 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:13:37,607 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:13:37,929 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:13:37,929 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:13:38,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:39,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:40,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:41,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:41,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:42,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:43,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:44,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:44,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:13:44,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:13:45,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:46,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:47,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:47,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:48,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:49,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:50,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:51,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:52,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:52,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:53,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:54,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:55,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:56,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:57,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:13:57,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:58,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:59,152 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:13:59,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:13:59,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:13:59,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:14:00,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:01,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:02,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:02,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:03,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:04,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:05,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:06,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:07,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:07,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:08,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:09,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:10,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:11,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:12,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:13,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:13,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:14,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:14,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:14:14,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:14:15,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:16,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:17,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:18,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:18,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:19,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:20,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:21,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:22,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:23,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:23,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:24,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:25,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:26,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:27,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:28,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:28,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:29,153 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:14:29,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:29,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:14:29,665 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:14:30,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:31,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:32,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:33,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:33,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:34,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:35,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:36,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:37,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:38,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:38,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:39,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:40,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:41,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:42,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:43,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:44,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:44,239 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:44,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:14:44,666 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:14:45,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:46,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:47,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:48,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:49,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:49,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:49,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:14:49,929 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:14:49,929 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:14:49,931 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:14:50,080 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:14:50,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:51,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:52,088 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:14:52,240 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:53,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:54,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:55,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:14:55,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:56,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:57,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:58,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:59,155 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:14:59,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:14:59,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:14:59,666 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:15:00,241 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:01,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:01,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:02,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:03,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:04,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:05,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:06,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:06,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:07,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:08,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:09,242 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:10,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:11,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:11,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:12,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:13,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:14,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:14,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:15:14,666 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:15:15,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:16,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:17,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:17,243 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:18,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:19,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:20,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:21,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:22,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:23,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:23,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:24,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:25,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:26,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:27,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:28,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:28,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:29,157 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:15:29,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:29,666 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:15:29,666 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:15:30,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:31,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:32,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:33,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:33,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:34,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:35,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:36,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:37,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:38,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:39,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:39,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:40,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:41,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:42,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:43,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:44,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:44,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:15:44,667 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:15:44,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:45,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:46,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:47,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:48,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:49,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:50,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:50,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:51,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:52,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:53,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:54,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:55,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:15:55,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:56,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:57,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:58,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:59,159 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:15:59,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:15:59,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:15:59,667 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:16:00,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:00,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:01,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:01,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:16:01,309 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:16:01,309 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:16:01,311 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:16:02,242 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:16:02,242 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:16:02,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:03,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:04,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:05,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:05,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:06,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:07,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:08,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:09,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:10,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:11,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:11,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:12,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:13,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:14,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:14,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:16:14,667 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:16:15,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:16,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:16,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:17,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:18,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:19,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:20,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:21,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:21,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:22,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:23,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:24,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:25,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:26,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:27,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:27,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:28,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:29,160 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:16:29,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:29,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:16:29,667 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:16:30,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:31,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:32,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:33,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:33,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:34,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:35,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:36,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:37,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:38,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:38,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:39,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:40,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:41,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:42,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:43,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:44,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:44,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:44,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:16:44,668 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:16:45,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:46,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:47,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:48,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:49,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:50,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:50,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:51,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:52,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:53,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:54,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:55,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:16:55,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:56,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:57,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:58,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:59,161 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:16:59,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:16:59,667 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:16:59,668 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:17:00,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:00,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:01,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:02,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:03,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:04,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:05,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:06,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:06,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:07,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:08,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:09,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:10,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:11,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:11,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:12,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:13,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:17:13,249 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:17:13,249 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:17:13,251 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:17:13,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:13,401 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:17:14,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:14,403 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:17:14,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:17:14,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:17:15,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:16,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:17,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:17,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:18,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:19,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:20,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:21,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:22,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:23,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:23,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:24,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:25,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:26,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:27,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:28,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:28,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:29,165 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:17:29,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:29,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:17:29,668 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:17:30,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:31,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:32,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:33,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:34,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:34,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:35,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:36,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:37,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:38,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:39,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:39,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:40,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:41,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:42,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:43,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:44,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:44,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:44,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:17:44,668 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:17:45,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:46,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:47,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:48,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:49,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:49,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:50,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:51,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:52,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:53,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:54,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:54,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:55,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:56,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:57,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:58,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:59,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:17:59,165 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:17:59,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:17:59,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:17:59,668 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:18:00,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:01,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:02,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:03,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:04,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:04,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:05,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:06,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:07,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:08,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:09,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:10,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:10,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:11,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:12,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:13,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:14,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:14,668 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:18:14,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:18:15,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:15,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:16,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:17,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:18,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:19,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:20,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:20,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:21,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:22,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:23,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:24,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:25,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:25,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:18:25,157 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:18:25,158 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:18:25,160 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:18:25,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:25,570 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:18:26,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:26,572 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:18:27,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:28,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:29,167 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:18:29,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:29,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:18:29,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:18:30,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:30,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:31,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:32,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:33,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:34,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:35,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:35,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:36,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:37,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:38,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:39,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:40,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:41,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:41,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:42,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:43,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:44,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:44,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:18:44,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:18:45,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:46,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:47,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:47,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:48,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:49,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:50,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:51,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:52,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:52,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:53,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:54,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:55,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:56,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:57,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:18:57,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:58,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:59,169 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:18:59,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:18:59,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:18:59,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:19:00,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:01,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:02,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:03,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:03,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:04,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:05,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:06,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:07,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:08,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:08,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:09,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:10,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:11,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:12,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:13,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:13,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:14,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:14,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:19:14,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:19:15,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:16,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:17,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:18,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:19,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:19,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:20,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:21,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:22,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:23,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:24,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:25,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:25,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:26,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:27,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:28,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:29,171 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:19:29,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:29,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:19:29,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:19:30,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:30,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:31,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:32,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:33,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:34,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:35,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:35,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:36,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:37,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:37,920 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:19:37,921 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:19:37,922 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:19:37,924 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:19:38,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:38,717 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:19:39,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:40,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:40,409 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:40,726 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:19:41,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:42,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:43,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:44,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:44,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:19:44,669 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:19:45,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:45,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:46,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:47,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:48,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:49,410 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:50,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:51,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:51,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:52,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:53,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:54,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:55,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:56,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:19:56,411 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:57,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:58,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:59,172 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:19:59,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:19:59,669 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:19:59,670 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:20:00,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:01,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:01,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:02,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:03,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:04,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:05,412 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:06,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:06,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:07,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:08,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:09,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:10,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:11,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:11,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:12,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:13,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:14,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:14,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:20:14,670 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:20:15,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:16,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:17,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:17,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:18,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:19,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:20,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:21,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:22,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:22,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:23,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:24,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:25,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:26,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:27,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:27,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:28,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:29,176 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:20:29,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:29,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:20:29,670 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:20:30,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:31,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:32,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:33,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:33,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:34,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:35,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:36,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:37,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:38,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:38,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:39,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:40,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:41,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:42,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:43,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:44,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:44,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:44,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:20:44,670 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:20:45,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:46,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:47,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:48,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:49,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:49,284 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:20:49,285 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:20:49,285 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:20:49,287 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:20:49,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:49,861 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:20:50,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:50,863 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:20:51,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:52,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:53,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:54,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:54,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:55,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:56,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:57,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:58,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:59,177 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:20:59,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:20:59,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:20:59,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:20:59,670 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:21:00,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:01,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:02,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:03,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:04,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:05,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:05,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:06,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:07,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:08,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:09,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:10,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:10,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:11,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:12,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:13,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:14,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:14,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:21:14,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:21:15,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:16,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:16,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:17,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:18,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:19,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:20,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:21,052 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:21,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:22,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:23,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:24,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:25,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:26,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:26,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:27,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:28,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:29,178 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:21:29,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:29,670 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:21:29,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:21:30,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:31,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:32,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:32,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:33,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:34,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:35,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:36,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:37,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:38,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:38,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:39,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:40,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:41,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:42,424 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:43,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:43,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:44,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:44,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:21:44,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:21:45,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:46,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:47,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:48,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:49,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:49,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:50,425 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:51,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:52,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:53,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:54,053 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:54,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:55,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:56,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:57,426 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:58,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:59,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:21:59,180 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:21:59,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:21:59,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:21:59,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:22:00,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:00,948 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:22:00,949 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:22:00,949 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:22:00,951 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:22:00,996 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:22:01,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:02,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:03,000 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:22:03,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:04,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:04,952 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:05,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:06,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:07,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:08,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:09,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:10,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:10,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:11,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:12,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:13,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:14,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:14,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:22:14,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:22:15,629 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:16,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:16,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:17,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:18,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:19,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:20,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:21,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:21,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:22,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:23,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:24,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:25,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:26,055 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:26,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:27,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:28,631 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:29,182 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:22:29,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:29,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:22:29,671 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:22:30,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:31,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:31,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:32,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:33,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:34,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:35,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:36,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:37,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:37,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:38,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:39,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:40,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:41,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:42,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:42,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:43,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:44,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:44,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:22:44,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:22:45,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:46,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:47,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:48,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:48,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:49,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:50,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:51,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:52,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:53,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:54,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:54,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:55,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:56,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:57,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:58,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:59,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:22:59,183 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:22:59,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:22:59,671 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:22:59,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:23:00,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:01,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:02,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:03,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:04,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:05,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:05,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:06,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:07,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:08,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:09,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:10,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:11,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:11,939 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:12,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:13,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:14,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:23:14,445 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:23:14,445 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:23:14,447 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:23:14,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:23:14,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:23:15,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:15,162 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:23:16,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:16,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:17,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:17,165 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:23:18,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:19,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:20,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:21,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:21,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:22,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:23,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:24,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:25,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:26,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:27,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:27,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:28,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:29,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:29,185 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:23:29,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:23:29,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:23:30,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:31,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:32,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:33,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:33,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:34,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:35,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:36,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:37,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:38,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:39,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:39,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:40,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:41,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:42,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:43,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:44,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:44,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:23:44,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:23:44,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:45,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:46,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:47,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:48,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:49,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:50,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:50,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:51,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:52,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:53,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:54,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:55,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:55,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:23:56,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:57,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:58,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:59,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:23:59,186 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:23:59,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:23:59,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:24:00,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:01,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:01,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:02,026 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:03,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:04,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:05,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:06,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:06,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:07,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:08,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:09,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:10,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:11,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:12,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:12,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:13,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:14,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:14,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:24:14,672 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:24:15,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:16,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:17,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:17,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:18,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:19,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:20,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:21,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:22,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:22,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:23,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:24,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:25,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:26,029 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:27,030 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:27,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:28,030 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:29,030 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:29,189 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:24:29,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:24:29,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:24:29,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:24:29,873 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:24:29,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:24:29,874 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:24:30,030 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:30,315 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:24:31,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:31,316 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:24:32,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:33,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:33,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:33,320 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:24:34,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:35,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:36,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:37,031 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:38,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:39,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:39,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:40,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:41,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:42,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:43,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:44,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:44,672 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:24:44,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:24:44,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:45,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:46,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:47,032 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:48,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:49,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:50,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:50,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:51,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:52,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:53,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:54,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:55,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:55,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:24:56,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:57,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:58,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:59,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:24:59,190 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:24:59,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:24:59,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:25:00,034 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:00,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:01,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:02,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:03,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:04,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:05,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:06,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:06,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:07,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:08,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:09,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:10,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:11,036 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:11,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:12,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:13,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:14,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:14,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:25:14,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:25:15,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:16,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:16,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:17,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:18,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:19,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:20,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:21,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:22,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:22,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:23,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:24,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:25,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:26,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:27,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:27,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:28,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:29,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:29,191 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:25:29,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:25:29,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:25:30,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:31,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:32,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:32,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:33,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:34,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:35,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:36,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:37,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:37,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:38,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:39,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:40,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:41,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:42,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:43,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:43,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:44,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:44,388 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:25:44,389 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:25:44,390 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:25:44,391 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:25:44,495 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:25:44,495 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:25:44,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:25:44,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:25:45,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:46,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:47,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:48,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:48,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:49,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:50,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:51,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:52,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:53,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:53,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:54,042 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:55,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:56,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:57,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:58,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:59,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:25:59,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:25:59,194 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:25:59,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:25:59,673 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:26:00,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:01,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:02,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:03,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:04,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:05,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:05,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:06,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:07,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:08,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:09,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:10,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:10,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:11,044 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:12,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:13,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:14,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:14,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:26:14,674 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:26:15,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:15,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:16,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:17,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:18,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:19,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:20,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:20,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:21,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:22,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:23,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:24,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:25,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:26,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:26,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:27,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:28,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:29,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:29,194 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:26:29,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:26:29,674 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:26:30,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:31,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:31,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:32,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:33,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:34,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:35,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:36,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:36,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:37,047 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:38,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:39,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:40,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:41,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:41,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:42,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:43,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:44,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:44,673 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:26:44,674 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:26:45,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:46,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:46,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:47,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:48,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:49,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:50,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:51,050 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:51,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:52,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:53,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:54,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:55,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:56,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:56,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:26:57,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:57,652 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:26:57,653 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:26:57,653 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:26:57,655 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:26:57,655 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:26:58,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:58,656 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:26:59,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:26:59,196 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:26:59,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:26:59,675 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:27:00,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:01,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:02,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:02,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:03,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:04,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:05,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:06,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:07,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:08,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:08,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:09,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:10,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:11,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:12,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:13,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:14,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:14,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:14,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:27:14,675 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:27:15,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:16,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:17,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:18,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:19,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:20,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:20,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:21,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:22,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:23,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:24,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:25,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:25,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:26,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:27,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:28,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:29,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:29,199 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:27:29,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:27:29,675 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:27:30,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:30,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:31,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:32,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:33,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:34,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:35,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:36,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:36,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:37,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:38,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:39,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:40,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:41,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:42,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:42,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:43,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:44,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:44,674 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:27:44,675 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:27:45,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:46,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:47,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:47,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:48,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:49,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:50,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:51,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:52,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:52,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:53,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:54,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:55,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:56,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:57,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:58,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:27:58,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:59,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:27:59,200 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:27:59,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:27:59,675 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:28:00,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:01,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:02,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:03,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:04,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:04,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:05,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:06,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:07,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:08,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:09,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:09,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:10,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:10,552 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:28:10,553 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:28:10,554 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:28:10,556 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:28:10,816 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:28:11,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:12,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:12,820 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:28:13,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:14,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:14,557 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:14,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:28:14,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:28:15,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:16,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:17,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:18,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:19,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:20,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:20,145 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:21,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:22,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:23,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:24,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:25,146 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:26,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:26,147 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:27,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:28,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:29,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:29,201 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:28:29,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:28:29,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:28:30,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:31,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:32,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:32,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:33,149 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:34,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:35,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:36,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:37,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:37,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:38,150 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:39,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:40,151 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:41,151 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:42,151 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:43,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:43,151 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:44,151 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:44,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:28:44,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:28:45,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:46,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:47,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:48,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:49,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:49,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:50,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:51,152 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:52,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:53,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:54,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:55,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:28:55,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:56,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:57,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:58,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:59,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:28:59,205 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:28:59,675 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:28:59,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:29:00,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:01,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:01,153 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:02,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:03,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:04,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:05,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:06,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:06,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:07,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:08,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:09,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:10,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:11,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:12,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:12,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:13,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:14,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:14,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:29:14,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:29:15,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:16,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:17,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:18,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:18,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:19,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:20,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:21,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:22,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:23,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:23,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:24,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:24,328 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:29:24,329 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:29:24,330 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:29:24,331 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:29:24,952 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:29:24,952 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:29:25,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:26,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:27,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:28,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:29,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:29,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:29,206 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:29:29,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:29:29,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:29:30,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:31,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:32,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:33,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:34,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:35,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:35,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:36,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:37,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:38,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:39,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:40,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:40,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:41,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:42,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:43,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:44,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:44,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:29:44,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:29:45,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:45,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:46,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:47,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:48,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:49,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:50,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:51,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:51,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:52,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:53,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:54,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:55,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:56,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:57,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:29:57,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:58,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:59,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:29:59,211 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:29:59,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:29:59,676 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:30:00,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:01,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:02,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:02,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:03,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:04,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:05,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:06,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:07,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:07,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:08,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:09,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:10,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:11,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:12,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:13,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:13,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:14,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:14,676 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:30:14,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:30:15,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:16,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:17,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:18,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:19,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:19,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:20,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:21,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:22,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:23,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:24,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:24,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:25,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:26,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:27,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:28,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:29,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:29,210 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:30:29,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:29,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:30:29,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:30:30,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:31,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:32,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:33,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:34,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:35,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:35,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:36,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:36,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:30:36,897 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:30:36,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:30:36,900 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:30:37,119 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:30:37,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:38,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:39,122 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:30:39,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:40,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:40,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:41,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:42,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:43,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:44,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:44,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:30:44,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:30:45,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:46,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:46,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:47,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:48,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:49,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:50,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:51,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:52,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:52,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:53,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:54,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:55,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:56,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:57,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:58,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:30:58,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:59,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:30:59,216 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:30:59,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:30:59,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:31:00,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:01,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:02,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:03,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:04,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:04,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:05,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:06,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:07,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:08,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:09,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:10,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:10,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:11,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:12,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:13,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:14,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:14,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:31:14,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:31:15,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:15,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:16,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:17,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:18,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:19,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:20,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:20,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:21,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:22,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:23,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:24,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:25,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:26,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:26,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:27,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:28,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:29,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:29,216 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:31:29,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:31:29,677 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:31:30,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:31,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:32,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:32,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:33,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:34,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:35,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:36,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:37,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:37,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:38,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:39,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:40,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:41,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:42,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:43,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:43,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:44,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:44,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:31:44,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:31:45,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:46,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:47,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:48,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:49,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:49,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:49,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:31:49,269 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:31:49,269 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:31:49,272 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:31:49,273 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:31:50,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:51,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:51,276 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:31:52,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:53,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:54,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:54,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:55,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:56,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:57,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:58,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:59,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:31:59,218 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:31:59,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:31:59,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:31:59,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:32:00,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:01,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:02,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:03,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:04,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:05,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:05,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:06,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:07,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:08,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:09,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:10,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:10,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:11,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:12,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:13,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:14,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:14,678 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:32:14,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:32:15,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:16,117 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:16,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:17,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:18,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:19,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:20,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:21,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:21,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:22,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:23,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:24,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:25,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:26,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:27,118 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:27,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:28,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:29,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:29,220 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:32:29,678 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:32:29,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:32:30,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:31,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:32,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:32,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:33,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:34,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:35,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:36,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:37,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:38,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:38,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:39,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:40,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:41,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:42,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:43,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:44,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:44,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:44,678 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:32:44,678 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:32:45,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:46,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:47,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:48,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:49,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:50,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:50,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:51,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:52,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:53,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:54,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:55,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:32:55,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:56,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:57,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:58,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:59,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:32:59,222 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:32:59,679 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:32:59,679 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:33:00,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:01,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:01,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:01,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:33:01,457 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:33:01,457 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:33:01,459 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:33:02,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:02,433 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:33:03,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:03,435 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:33:04,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:05,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:06,119 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:06,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:07,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:08,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:09,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:10,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:11,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:11,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:12,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:13,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:14,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:14,678 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:33:14,679 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:33:15,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:16,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:17,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:17,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:18,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:19,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:20,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:21,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:22,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:23,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:23,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:24,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:25,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:26,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:27,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:28,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:29,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:29,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:29,223 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:33:29,679 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:33:29,679 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:33:30,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:31,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:32,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:33,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:34,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:34,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:35,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:36,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:37,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:38,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:39,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:40,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:40,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:41,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:42,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:43,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:44,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:44,679 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:33:44,679 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:33:45,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:45,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:46,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:47,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:48,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:49,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:50,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:51,120 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:51,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:52,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:53,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:54,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:55,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:56,121 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:33:56,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:57,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:58,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:59,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:33:59,225 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:33:59,679 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:33:59,679 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:34:00,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:01,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:01,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:02,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:03,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:04,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:05,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:06,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:07,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:07,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:08,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:09,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:10,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:11,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:12,122 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:12,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:13,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:14,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:14,284 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:34:14,285 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:34:14,285 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:34:14,287 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:34:14,606 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:34:14,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:34:14,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:34:15,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:15,607 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:34:16,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:17,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:18,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:18,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:19,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:20,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:21,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:22,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:23,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:24,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:24,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:25,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:26,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:27,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:28,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:29,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:29,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:29,227 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:34:29,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:34:29,858 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:34:30,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:31,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:32,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:33,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:34,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:35,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:35,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:36,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:37,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:38,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:39,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:40,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:40,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:41,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:42,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:43,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:44,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:44,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:34:44,858 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:34:45,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:46,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:46,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:47,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:48,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:49,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:50,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:51,123 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:51,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:52,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:53,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:54,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:55,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:56,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:34:56,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:57,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:58,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:59,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:34:59,231 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:34:59,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:34:59,859 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:35:00,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:01,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:01,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:02,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:03,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:04,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:05,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:06,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:06,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:07,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:08,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:09,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:10,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:11,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:12,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:12,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:13,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:14,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:14,858 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:35:14,858 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:35:15,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:16,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:17,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:18,124 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:18,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:19,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:20,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:21,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:22,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:23,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:23,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:24,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:25,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:26,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:27,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:27,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:35:27,345 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:35:27,345 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:35:27,347 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:35:27,751 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:35:28,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:28,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:29,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:29,232 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:35:29,754 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:35:29,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:35:29,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:35:30,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:31,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:32,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:33,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:34,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:34,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:35,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:36,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:37,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:38,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:39,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:39,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:40,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:41,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:42,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:43,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:44,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:44,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:44,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:35:44,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:35:45,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:46,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:47,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:48,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:49,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:50,125 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:50,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:51,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:52,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:53,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:54,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:55,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:35:55,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:56,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:57,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:58,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:59,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:35:59,235 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:35:59,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:35:59,859 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:36:00,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:01,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:01,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:02,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:03,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:04,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:05,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:06,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:06,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:07,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:08,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:09,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:10,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:11,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:12,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:12,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:13,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:14,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:14,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:36:14,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:36:15,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:16,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:17,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:18,126 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:18,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:19,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:20,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:21,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:22,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:23,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:23,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:24,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:25,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:26,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:27,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:28,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:28,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:29,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:29,236 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:36:29,859 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:36:29,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:36:30,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:31,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:32,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:33,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:34,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:34,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:35,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:36,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:37,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:38,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:39,127 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:39,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:39,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:36:39,705 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:36:39,705 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:36:39,706 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:36:39,892 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:36:40,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:41,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:41,896 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:36:42,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:43,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:44,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:44,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:44,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:36:44,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:36:45,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:46,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:47,244 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:48,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:49,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:50,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:50,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:51,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:52,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:53,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:54,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:55,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:56,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:36:56,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:57,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:58,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:59,238 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:36:59,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:36:59,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:36:59,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:37:00,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:01,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:01,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:02,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:03,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:04,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:05,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:06,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:07,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:07,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:08,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:09,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:10,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:11,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:12,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:12,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:13,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:14,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:14,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:37:14,860 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:37:15,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:16,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:17,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:18,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:18,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:19,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:20,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:21,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:22,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:23,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:23,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:24,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:25,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:26,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:27,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:28,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:28,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:29,241 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:37:29,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:29,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:37:29,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:37:30,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:31,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:32,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:33,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:34,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:34,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:35,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:36,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:37,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:38,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:39,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:40,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:40,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:41,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:42,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:43,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:44,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:44,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:37:44,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:37:45,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:45,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:46,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:47,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:48,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:49,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:50,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:50,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:51,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:52,308 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:52,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:37:52,841 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:37:52,841 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:37:52,843 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:37:53,043 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:37:53,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:54,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:55,047 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:37:55,311 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:37:55,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:56,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:57,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:58,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:59,241 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:37:59,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:37:59,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:37:59,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:38:00,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:00,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:01,429 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:02,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:03,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:04,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:05,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:06,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:06,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:07,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:08,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:09,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:10,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:11,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:12,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:12,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:13,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:14,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:14,860 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:38:14,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:38:15,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:16,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:17,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:17,431 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:18,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:19,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:20,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:21,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:22,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:23,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:23,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:24,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:25,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:26,432 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:27,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:28,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:29,243 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:38:29,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:29,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:29,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:38:29,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:38:30,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:31,433 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:32,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:33,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:34,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:34,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:35,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:36,434 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:37,436 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:38,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:39,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:40,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:40,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:41,435 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:42,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:43,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:44,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:44,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:38:44,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:38:45,312 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:45,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:46,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:47,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:48,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:49,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:50,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:50,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:51,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:52,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:53,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:54,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:55,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:38:55,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:56,439 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:57,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:58,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:59,245 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:38:59,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:38:59,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:38:59,861 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:39:00,313 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:00,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:01,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:02,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:03,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:04,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:05,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:05,441 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:05,816 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:39:05,817 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:39:05,818 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:39:05,820 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:39:06,209 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:39:06,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:07,211 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:39:07,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:08,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:09,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:10,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:11,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:11,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:12,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:13,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:14,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:14,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:39:14,862 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:39:15,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:16,442 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:17,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:17,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:18,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:19,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:20,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:21,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:22,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:23,314 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:23,443 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:24,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:25,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:26,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:27,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:28,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:28,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:29,247 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:39:29,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:29,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:39:29,862 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:39:30,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:31,444 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:32,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:33,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:34,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:34,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:35,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:36,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:37,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:38,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:39,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:39,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:40,445 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:41,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:42,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:43,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:44,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:44,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:44,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:39:44,862 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:39:45,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:46,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:47,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:48,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:49,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:50,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:50,446 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:51,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:52,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:53,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:54,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:55,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:56,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:39:56,447 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:57,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:58,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:59,251 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:39:59,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:39:59,861 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:39:59,862 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:40:00,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:01,315 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:01,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:02,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:03,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:04,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:05,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:06,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:06,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:07,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:08,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:09,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:10,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:11,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:11,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:12,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:13,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:14,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:14,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:40:14,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:40:15,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:16,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:17,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:17,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:18,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:19,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:40:19,190 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:40:19,190 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:40:19,192 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:40:19,359 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:40:19,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:20,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:21,363 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:40:21,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:22,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:22,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:23,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:24,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:25,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:26,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:27,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:28,316 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:28,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:29,252 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:40:29,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:29,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:40:29,863 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:40:30,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:31,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:32,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:33,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:33,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:34,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:35,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:36,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:37,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:38,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:39,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:39,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:40,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:41,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:42,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:43,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:44,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:44,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:44,862 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:40:44,863 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:40:45,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:46,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:47,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:48,456 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:49,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:49,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:50,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:51,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:52,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:53,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:54,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:55,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:40:55,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:56,457 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:57,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:58,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:59,255 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:40:59,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:40:59,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:40:59,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:41:00,317 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:00,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:01,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:02,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:03,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:04,458 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:05,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:06,326 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:06,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:07,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:08,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:09,459 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:10,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:11,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:12,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:12,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:13,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:14,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:14,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:41:14,863 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:41:15,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:16,460 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:17,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:18,318 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:18,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:19,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:20,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:21,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:22,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:23,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:23,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:24,461 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:25,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:26,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:27,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:28,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:29,257 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:41:29,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:29,462 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:29,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:41:29,863 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:41:30,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:31,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:32,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:33,463 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:33,680 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:41:33,681 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:41:33,681 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:41:33,682 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:41:34,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:34,506 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:41:34,787 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:35,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:35,507 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:41:36,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:37,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:38,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:39,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:40,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:40,464 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:41,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:42,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:43,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:44,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:44,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:41:44,863 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:41:45,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:45,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:46,465 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:47,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:48,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:49,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:50,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:50,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:51,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:52,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:53,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:54,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:55,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:56,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:41:56,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:57,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:58,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:59,260 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:41:59,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:41:59,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:41:59,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:42:00,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:01,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:01,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:02,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:03,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:04,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:05,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:06,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:07,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:07,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:08,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:09,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:10,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:11,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:12,320 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:12,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:13,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:14,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:14,863 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:42:14,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:42:15,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:16,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:17,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:17,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:18,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:19,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:20,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:21,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:22,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:23,321 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:23,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:24,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:25,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:26,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:27,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:28,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:28,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:29,262 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:42:29,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:29,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:42:29,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:42:30,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:31,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:32,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:33,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:34,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:34,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:35,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:36,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:37,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:38,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:39,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:39,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:40,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:41,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:42,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:43,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:44,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:44,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:42:44,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:42:45,033 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:45,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:46,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:46,733 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:42:46,734 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:42:46,735 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:42:46,736 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:42:47,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:47,663 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:42:47,663 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:42:48,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:49,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:50,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:50,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:51,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:52,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:53,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:54,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:55,322 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:42:55,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:56,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:57,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:58,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:59,265 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:42:59,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:42:59,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:42:59,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:43:00,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:00,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:01,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:02,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:03,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:04,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:05,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:06,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:06,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:07,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:08,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:09,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:10,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:11,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:12,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:12,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:13,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:14,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:14,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:43:14,864 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:43:15,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:16,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:17,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:18,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:18,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:19,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:20,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:21,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:22,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:23,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:24,323 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:24,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:25,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:26,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:27,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:28,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:29,265 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:43:29,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:29,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:43:29,865 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:43:30,035 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:30,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:31,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:32,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:33,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:34,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:35,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:35,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:36,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:37,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:38,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:39,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:40,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:41,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:41,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:42,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:43,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:44,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:44,864 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:43:44,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:43:45,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:46,325 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:46,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:47,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:48,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:49,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:50,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:51,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:52,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:52,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:53,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:54,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:55,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:56,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:57,324 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:43:57,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:58,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:59,267 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:43:59,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:43:59,552 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:43:59,553 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:43:59,553 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:43:59,555 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:43:59,833 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:43:59,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:43:59,865 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:44:00,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:01,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:01,837 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:44:02,329 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:02,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:03,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:04,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:05,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:06,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:07,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:07,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:08,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:09,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:10,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:11,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:12,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:13,329 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:13,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:14,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:14,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:44:14,865 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:44:15,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:16,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:17,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:18,329 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:18,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:19,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:20,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:21,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:22,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:23,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:23,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:24,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:25,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:26,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:27,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:28,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:28,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:29,269 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:44:29,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:29,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:44:29,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:44:30,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:31,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:32,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:33,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:34,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:34,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:35,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:36,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:37,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:38,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:39,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:39,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:40,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:41,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:42,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:43,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:44,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:44,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:44:44,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:44:45,037 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:45,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:46,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:47,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:48,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:49,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:50,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:50,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:51,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:52,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:53,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:54,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:55,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:56,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:44:56,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:57,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:58,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:59,271 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:44:59,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:44:59,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:44:59,865 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:45:00,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:01,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:01,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:02,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:03,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:04,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:05,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:06,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:07,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:07,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:08,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:09,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:10,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:11,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:12,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:12,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:13,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:13,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:45:13,833 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:45:13,833 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:45:13,835 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:45:13,972 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:45:14,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:14,865 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:45:14,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:45:15,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:15,975 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:45:16,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:17,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:17,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:18,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:19,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:20,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:21,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:22,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:23,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:23,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:24,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:25,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:26,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:27,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:28,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:28,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:29,273 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:45:29,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:29,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:45:29,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:45:30,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:31,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:32,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:33,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:33,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:34,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:35,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:36,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:37,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:38,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:39,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:39,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:40,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:41,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:42,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:43,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:44,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:44,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:44,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:45:44,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:45:45,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:46,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:47,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:48,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:49,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:50,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:50,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:51,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:52,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:53,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:54,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:55,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:45:55,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:56,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:57,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:58,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:59,276 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:45:59,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:45:59,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:45:59,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:46:00,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:00,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:01,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:02,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:03,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:04,511 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:05,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:06,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:06,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:07,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:08,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:09,510 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:10,511 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:11,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:11,511 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:12,511 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:13,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:14,511 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:14,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:46:14,866 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:46:15,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:16,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:17,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:17,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:18,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:19,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:20,512 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:21,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:22,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:22,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:23,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:24,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:25,513 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:26,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:27,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:28,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:28,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:29,278 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:46:29,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:46:29,498 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:46:29,498 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:46:29,500 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:46:29,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:46:29,867 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:46:29,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:30,126 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:46:30,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:31,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:32,129 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:46:32,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:33,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:33,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:34,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:35,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:36,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:37,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:38,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:39,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:39,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:40,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:41,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:42,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:43,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:44,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:44,866 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:46:44,867 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:46:44,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:45,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:46,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:47,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:48,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:49,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:50,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:50,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:51,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:52,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:53,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:54,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:55,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:46:55,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:56,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:57,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:58,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:46:59,279 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:46:59,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:46:59,867 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:46:59,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:00,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:00,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:01,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:02,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:03,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:04,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:05,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:05,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:06,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:07,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:08,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:09,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:10,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:10,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:11,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:12,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:13,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:14,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:47:14,867 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:47:14,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:15,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:16,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:16,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:17,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:18,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:19,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:20,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:21,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:21,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:22,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:23,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:24,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:25,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:26,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:26,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:27,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:28,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:29,283 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:47:29,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:47:29,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:47:29,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:30,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:31,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:31,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:32,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:33,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:34,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:35,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:36,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:37,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:37,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:38,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:39,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:40,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:41,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:42,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:43,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:43,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:44,824 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:47:44,825 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:47:44,826 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:47:44,828 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:47:44,867 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:47:44,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:47:44,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:45,290 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:47:45,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:46,291 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:47:46,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:47,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:48,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:48,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:49,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:50,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:51,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:52,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:53,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:54,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:47:54,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:55,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:56,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:57,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:58,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:47:59,283 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:47:59,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:47:59,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:47:59,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:00,041 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:00,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:01,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:02,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:03,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:04,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:05,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:05,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:06,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:07,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:08,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:09,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:10,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:11,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:11,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:12,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:13,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:14,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:48:14,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:48:14,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:15,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:16,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:16,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:17,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:18,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:19,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:20,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:21,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:22,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:22,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:23,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:24,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:25,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:26,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:27,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:27,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:28,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:29,285 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:48:29,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:48:29,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:48:29,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:30,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:31,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:32,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:33,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:33,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:34,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:35,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:36,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:37,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:38,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:38,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:39,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:40,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:41,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:42,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:43,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:44,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:44,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:48:44,868 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:48:44,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:45,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:46,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:47,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:48,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:49,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:50,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:50,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:51,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:52,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:53,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:55,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:56,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:56,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:48:57,040 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:57,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:48:57,493 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:48:57,493 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:48:57,495 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:48:58,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:58,441 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:48:59,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:48:59,287 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:48:59,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:48:59,869 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:49:00,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:00,444 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:49:01,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:01,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:02,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:03,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:04,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:05,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:06,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:07,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:07,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:08,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:09,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:10,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:11,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:12,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:13,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:13,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:14,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:14,868 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:49:14,869 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:49:15,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:16,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:17,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:18,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:19,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:19,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:20,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:21,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:22,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:23,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:24,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:24,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:25,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:26,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:27,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:28,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:29,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:29,289 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:49:29,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:49:29,869 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:49:30,038 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:30,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:31,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:32,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:33,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:34,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:35,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:35,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:36,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:37,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:38,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:39,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:40,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:41,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:41,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:42,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:43,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:44,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:44,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:49:44,869 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:49:45,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:46,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:47,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:47,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:48,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:49,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:50,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:51,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:52,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:52,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:53,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:54,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:55,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:56,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:57,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:58,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:58,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:49:59,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:49:59,290 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:49:59,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:49:59,869 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:50:00,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:01,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:02,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:03,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:03,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:04,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:05,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:06,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:07,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:08,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:08,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:09,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:10,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:11,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:11,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:50:11,503 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:50:11,503 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:50:11,505 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:50:11,618 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:50:12,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:13,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:13,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:13,622 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:50:14,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:14,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:50:14,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:50:15,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:16,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:17,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:18,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:19,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:19,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:20,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:21,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:22,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:23,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:24,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:25,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:25,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:26,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:27,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:28,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:29,292 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:50:29,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:29,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:50:29,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:50:30,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:31,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:31,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:32,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:33,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:34,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:35,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:36,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:37,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:37,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:38,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:39,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:40,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:41,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:42,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:42,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:43,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:44,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:44,869 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:50:44,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:50:45,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:46,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:47,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:48,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:48,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:49,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:50,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:51,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:52,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:53,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:53,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:54,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:55,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:56,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:57,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:58,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:59,294 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:50:59,297 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:50:59,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:50:59,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:50:59,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:51:00,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:01,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:02,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:03,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:04,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:04,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:05,359 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:06,360 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:07,360 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:08,360 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:09,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:09,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:10,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:11,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:12,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:13,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:14,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:14,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:51:14,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:51:15,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:15,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:16,361 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:17,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:18,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:19,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:20,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:20,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:21,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:22,362 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:23,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:24,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:25,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:25,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:25,976 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:51:25,977 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:51:25,978 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:51:25,979 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:51:26,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:26,760 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:51:27,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:27,766 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:51:28,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:29,295 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:51:29,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:29,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:51:29,871 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:51:30,519 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:30,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:31,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:32,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:33,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:34,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:35,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:36,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:36,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:37,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:38,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:39,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:40,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:41,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:42,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:42,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:43,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:44,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:44,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:51:44,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:51:45,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:46,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:47,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:47,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:48,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:49,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:50,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:51,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:52,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:52,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:53,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:54,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:55,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:56,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:57,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:51:57,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:58,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:59,298 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:51:59,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:51:59,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:51:59,871 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:52:00,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:01,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:02,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:03,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:03,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:04,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:05,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:06,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:07,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:08,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:09,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:09,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:10,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:11,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:12,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:13,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:14,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:14,870 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:52:14,870 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:52:15,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:15,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:16,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:17,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:18,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:19,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:20,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:20,573 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:21,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:22,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:23,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:24,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:25,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:25,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:26,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:27,574 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:28,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:29,301 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:52:29,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:29,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:52:29,871 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:52:30,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:30,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:31,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:32,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:33,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:34,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:35,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:36,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:36,575 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:37,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:38,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:39,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:40,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:52:40,046 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:52:40,046 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:52:40,048 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:52:40,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:40,899 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:52:41,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:41,633 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:41,901 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:52:42,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:43,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:44,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:44,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:52:44,872 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:52:45,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:46,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:46,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:47,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:48,634 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:49,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:50,635 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:51,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:52,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:52,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:53,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:54,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:55,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:56,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:57,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:52:57,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:58,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:59,303 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:52:59,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:52:59,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:52:59,872 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:53:00,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:01,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:02,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:02,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:03,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:04,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:05,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:06,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:07,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:08,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:08,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:09,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:10,637 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:11,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:12,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:13,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:14,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:14,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:14,871 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:53:14,872 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:53:15,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:16,638 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:17,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:18,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:19,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:19,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:20,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:21,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:22,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:23,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:24,639 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:25,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:25,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:26,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:27,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:28,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:29,305 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:53:29,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:29,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:53:29,872 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:53:30,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:30,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:31,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:32,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:33,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:34,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:35,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:35,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:36,641 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:37,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:38,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:39,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:40,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:41,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:41,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:42,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:43,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:44,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:44,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:53:44,872 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:53:45,642 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:46,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:47,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:47,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:48,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:49,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:50,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:51,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:52,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:52,643 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:53,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:54,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:55,644 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:56,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:53:56,113 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:53:56,114 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:53:56,115 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:53:57,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:57,041 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:53:58,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:58,043 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:53:58,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:53:59,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:53:59,307 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:53:59,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:53:59,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:54:00,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:01,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:02,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:03,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:03,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:04,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:05,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:06,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:07,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:08,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:09,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:09,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:10,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:11,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:12,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:13,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:14,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:14,872 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:54:14,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:54:15,017 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:15,043 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:16,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:17,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:18,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:19,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:20,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:20,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:21,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:22,018 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:23,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:24,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:25,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:26,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:26,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:27,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:28,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:29,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:29,308 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:54:29,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:54:29,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:54:30,019 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:31,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:32,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:32,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:33,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:34,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:35,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:36,020 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:37,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:37,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:38,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:39,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:40,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:41,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:42,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:42,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:43,021 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:44,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:44,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:54:44,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:54:45,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:46,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:47,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:48,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:48,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:49,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:50,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:51,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:52,022 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:53,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:54,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:54,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:54:55,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:56,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:57,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:58,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:59,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:54:59,310 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:54:59,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:54:59,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:55:00,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:00,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:01,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:02,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:03,023 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:04,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:05,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:05,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:06,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:07,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:08,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:09,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:10,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:10,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:11,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:12,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:13,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:13,128 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:55:13,129 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:55:13,129 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:55:13,131 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:55:13,194 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:55:14,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:14,195 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:55:14,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:55:14,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:55:15,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:15,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:16,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:17,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:18,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:19,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:20,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:20,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:21,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:22,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:23,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:24,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:25,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:26,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:26,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:27,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:28,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:29,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:29,311 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:55:29,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:55:29,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:55:30,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:31,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:31,688 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:32,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:33,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:34,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:35,074 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:36,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:37,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:37,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:38,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:39,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:40,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:41,075 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:42,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:42,688 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:43,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:44,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:44,873 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:55:44,873 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:55:45,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:46,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:47,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:47,688 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:48,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:49,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:50,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:51,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:52,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:53,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:53,688 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:54,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:55,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:56,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:57,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:58,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:58,688 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:55:59,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:55:59,314 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:55:59,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:55:59,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:56:00,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:01,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:02,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:03,078 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:03,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:04,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:05,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:06,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:07,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:08,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:09,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:09,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:10,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:11,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:12,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:13,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:14,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:14,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:14,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:56:14,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:56:15,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:16,080 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:17,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:18,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:19,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:20,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:20,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:21,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:22,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:23,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:24,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:25,082 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:26,081 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:26,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:27,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:28,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:29,083 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:29,315 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:56:29,404 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:56:29,405 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:56:29,405 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:56:29,406 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:56:29,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:56:29,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:56:30,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:30,340 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:56:30,340 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:56:31,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:31,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:32,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:32,343 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:56:33,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:34,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:35,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:36,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:36,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:37,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:38,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:39,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:40,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:41,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:42,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:42,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:43,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:44,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:44,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:56:44,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:56:45,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:46,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:47,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:48,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:48,689 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:49,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:50,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:51,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:52,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:53,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:53,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:54,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:55,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:56,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:57,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:58,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:59,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:56:59,316 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:56:59,319 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:56:59,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:56:59,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:57:00,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:01,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:02,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:03,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:04,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:04,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:05,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:06,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:07,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:08,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:09,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:10,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:10,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:11,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:12,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:13,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:14,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:14,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:57:14,874 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:57:15,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:16,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:16,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:17,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:18,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:19,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:20,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:21,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:21,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:22,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:23,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:24,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:25,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:26,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:26,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:27,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:28,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:29,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:29,319 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:57:29,874 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:57:29,875 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:57:30,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:31,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:32,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:32,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:33,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:34,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:35,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:36,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:37,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:38,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:38,690 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:39,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:40,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:41,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:42,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:43,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:43,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:44,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:57:44,009 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:57:44,009 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:57:44,011 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:57:44,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:44,465 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:57:44,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:57:44,876 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:57:45,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:46,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:46,468 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:57:47,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:48,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:48,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:49,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:50,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:51,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:52,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:53,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:53,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:54,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:55,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:56,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:57,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:58,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:58,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:57:59,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:57:59,319 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:57:59,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:57:59,875 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:58:00,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:01,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:02,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:03,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:04,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:04,691 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:05,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:06,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:07,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:08,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:09,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:09,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:10,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:11,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:12,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:13,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:14,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:14,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:58:14,875 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:58:15,045 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:15,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:16,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:17,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:18,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:19,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:20,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:20,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:21,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:22,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:23,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:24,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:25,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:25,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:26,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:27,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:28,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:29,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:29,322 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:58:29,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:58:29,875 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:58:30,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:31,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:31,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:32,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:33,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:34,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:35,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:36,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:36,692 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:37,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:38,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:39,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:40,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:41,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:41,693 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:42,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:43,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:44,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:44,875 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:58:44,875 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:58:45,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:46,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:47,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:47,693 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:48,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:49,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:50,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:51,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:52,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:52,693 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:53,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:54,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:55,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:56,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:57,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:57,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:58:58,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:58,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-10 23:58:58,441 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-10 23:58:58,441 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-10 23:58:58,442 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-10 23:58:58,630 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-10 23:58:59,324 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:58:59,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:58:59,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:58:59,876 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:59:00,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:00,635 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-10 23:59:01,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:02,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:03,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:03,980 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:04,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:05,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:06,466 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:07,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:08,467 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:09,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:09,979 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:10,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:11,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:12,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:13,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:14,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:14,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:59:14,876 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:59:15,046 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:15,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:16,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:17,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:18,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:19,469 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:20,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:20,980 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:21,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:22,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:23,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:24,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:25,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:26,470 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:26,980 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:27,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:28,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:29,325 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:59:29,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:29,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:59:29,876 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:59:30,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:31,471 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:31,980 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:32,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:33,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:34,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:35,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:36,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:36,980 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:37,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:38,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:39,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:40,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:41,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:41,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:42,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:43,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:44,473 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:44,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:59:44,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-10 23:59:45,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:46,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:46,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:47,474 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:48,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:49,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:50,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:51,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:52,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:52,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:53,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:54,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:55,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:56,475 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:57,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:57,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-10 23:59:58,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:59,327 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-10 23:59:59,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-10 23:59:59,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-10 23:59:59,876 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:00:00,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:01,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:02,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:03,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:03,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:04,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:05,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:06,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:07,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:08,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:08,981 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:09,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:10,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:11,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:12,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:13,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:13,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:00:13,597 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:00:13,597 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:00:13,600 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:00:13,769 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:00:14,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:14,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:14,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:00:14,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:00:15,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:16,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:16,775 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:00:17,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:18,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:19,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:19,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:20,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:21,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:22,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:23,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:24,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:25,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:25,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:26,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:27,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:28,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:29,328 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:00:29,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:29,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:00:29,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:00:30,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:31,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:31,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:32,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:33,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:34,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:35,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:36,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:36,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:37,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:38,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:39,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:40,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:41,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:42,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:42,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:43,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:44,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:44,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:00:44,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:00:45,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:46,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:47,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:47,982 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:48,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:49,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:50,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:51,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:52,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:53,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:53,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:54,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:55,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:56,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:57,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:58,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:58,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:00:59,331 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:00:59,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:00:59,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:00:59,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:01:00,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:01,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:02,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:03,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:03,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:04,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:05,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:06,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:07,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:08,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:08,983 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:09,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:10,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:11,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:12,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:13,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:13,984 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:14,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:14,877 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:01:14,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:01:15,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:16,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:17,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:18,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:19,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:19,984 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:20,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:21,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:22,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:23,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:24,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:24,984 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:25,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:26,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:27,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:28,472 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:01:28,473 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:01:28,473 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:01:28,475 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:01:28,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:28,910 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:01:29,333 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:01:29,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:29,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:01:29,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:01:30,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:30,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:30,913 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:01:31,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:32,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:33,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:34,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:35,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:35,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:36,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:37,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:38,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:39,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:40,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:40,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:41,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:42,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:43,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:44,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:44,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:01:44,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:01:45,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:46,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:46,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:47,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:48,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:49,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:50,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:51,154 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:51,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:52,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:53,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:54,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:55,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:56,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:01:56,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:57,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:58,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:59,334 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:01:59,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:01:59,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:01:59,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:02:00,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:01,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:01,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:02,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:03,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:04,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:05,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:06,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:06,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:07,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:08,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:09,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:10,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:11,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:12,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:12,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:13,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:14,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:14,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:02:14,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:02:15,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:16,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:17,155 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:17,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:18,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:19,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:20,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:21,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:22,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:23,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:23,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:24,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:25,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:26,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:27,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:28,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:28,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:29,338 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:02:29,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:29,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:02:29,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:02:30,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:31,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:32,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:33,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:34,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:34,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:35,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:36,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:37,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:38,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:39,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:39,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:40,630 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:41,627 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:42,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:43,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:02:43,093 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:02:43,093 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:02:43,095 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:02:44,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:44,036 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:02:44,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:02:44,878 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:02:45,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:45,038 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:02:45,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:46,003 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:47,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:48,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:49,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:50,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:50,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:51,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:52,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:53,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:54,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:55,004 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:56,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:56,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:02:57,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:58,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:59,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:02:59,338 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:02:59,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:02:59,879 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:03:00,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:01,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:01,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:02,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:03,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:04,005 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:05,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:06,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:07,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:07,156 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:08,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:09,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:10,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:11,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:12,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:13,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:13,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:14,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:14,878 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:03:14,879 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:03:15,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:16,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:17,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:18,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:18,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:19,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:20,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:21,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:22,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:23,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:23,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:24,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:25,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:26,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:27,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:28,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:28,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:29,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:29,340 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:03:29,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:03:29,879 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:03:30,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:31,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:32,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:33,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:34,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:34,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:35,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:36,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:37,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:38,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:39,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:40,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:40,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:41,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:42,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:43,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:44,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:44,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:03:44,879 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:03:45,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:46,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:46,049 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:47,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:48,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:49,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:50,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:51,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:51,157 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:52,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:53,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:54,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:55,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:56,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:56,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:03:57,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:58,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:58,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:03:58,597 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:03:58,597 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:03:58,599 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:03:59,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:03:59,199 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:03:59,344 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:03:59,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:03:59,880 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:04:00,085 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:00,200 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:04:01,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:01,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:02,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:03,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:04,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:05,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:06,086 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:07,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:07,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:08,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:09,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:10,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:11,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:12,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:13,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:13,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:14,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:14,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:04:14,880 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:04:15,087 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:16,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:17,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:18,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:18,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:19,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:20,088 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:21,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:22,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:23,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:24,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:24,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:25,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:26,089 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:27,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:28,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:29,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:29,158 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:29,343 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:04:29,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:04:29,880 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:04:30,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:31,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:32,090 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:33,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:34,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:34,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:35,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:36,091 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:37,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:38,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:39,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:39,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:40,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:41,092 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:42,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:43,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:44,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:44,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:44,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:04:44,880 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:04:45,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:46,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:47,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:48,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:49,093 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:50,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:50,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:51,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:52,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:53,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:54,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:55,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:55,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:04:56,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:57,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:58,094 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:59,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:04:59,346 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:04:59,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:04:59,880 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:05:00,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:01,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:01,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:02,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:03,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:04,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:05,095 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:06,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:06,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:07,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:08,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:09,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:10,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:11,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:11,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:12,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:13,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:13,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:05:13,237 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:05:13,238 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:05:13,239 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:05:13,328 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:05:14,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:14,330 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:05:14,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:05:14,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:05:15,097 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:16,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:16,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:17,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:18,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:19,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:20,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:21,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:22,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:22,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:23,098 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:24,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:25,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:26,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:27,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:27,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:28,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:29,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:29,347 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:05:29,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:05:29,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:05:30,099 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:31,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:32,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:32,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:33,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:34,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:35,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:36,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:37,100 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:37,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:38,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:39,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:40,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:41,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:42,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:43,101 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:43,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:44,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:44,880 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:05:44,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:05:45,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:46,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:47,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:48,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:49,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:49,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:50,102 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:51,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:52,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:53,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:54,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:54,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:55,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:56,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:57,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:58,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:59,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:05:59,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:05:59,349 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:05:59,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:05:59,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:06:00,103 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:01,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:02,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:03,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:04,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:04,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:05,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:06,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:07,104 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:08,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:09,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:09,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:10,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:11,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:12,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:13,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:14,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:14,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:14,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:06:14,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:06:15,105 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:16,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:17,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:18,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:19,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:20,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:20,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:21,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:22,106 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:23,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:24,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:24,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:06:24,877 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:06:24,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:06:24,879 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:06:25,107 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:25,463 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:06:25,879 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:26,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:26,465 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:06:27,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:28,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:29,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:29,349 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:06:29,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:06:29,881 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:06:30,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:31,051 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:31,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:32,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:33,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:34,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:35,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:36,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:36,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:37,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:38,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:39,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:40,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:41,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:41,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:42,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:43,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:44,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:44,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:06:44,882 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:06:45,109 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:46,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:46,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:47,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:48,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:49,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:50,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:51,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:51,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:52,110 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:53,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:54,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:55,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:56,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:57,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:57,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:06:58,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:59,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:06:59,351 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:06:59,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:06:59,882 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:07:00,111 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:01,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:02,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:02,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:03,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:04,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:05,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:06,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:07,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:07,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:08,112 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:09,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:10,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:11,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:12,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:12,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:13,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:14,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:14,881 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:07:14,882 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:07:15,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:16,113 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:17,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:17,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:18,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:19,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:20,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:21,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:22,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:22,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:23,114 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:24,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:25,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:26,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:27,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:28,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:28,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:29,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:29,353 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:07:29,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:07:29,882 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:07:30,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:31,115 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:32,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:33,116 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:33,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:34,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:35,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:36,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:36,628 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:07:36,629 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:07:36,629 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:07:36,631 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:07:37,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:37,609 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:07:38,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:38,611 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:07:38,632 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:39,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:40,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:41,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:42,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:43,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:44,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:44,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:44,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:07:44,882 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:07:45,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:46,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:47,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:48,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:49,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:50,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:50,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:51,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:52,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:53,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:54,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:55,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:07:55,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:56,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:57,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:58,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:59,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:07:59,355 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:07:59,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:07:59,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:08:00,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:01,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:01,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:02,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:03,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:04,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:05,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:06,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:06,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:07,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:08,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:09,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:10,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:11,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:12,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:12,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:13,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:14,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:14,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:08:14,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:08:15,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:16,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:17,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:17,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:18,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:19,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:20,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:21,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:22,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:22,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:23,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:24,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:25,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:26,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:27,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:28,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:28,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:29,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:29,356 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:08:29,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:08:29,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:08:30,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:31,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:32,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:33,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:33,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:34,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:35,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:36,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:37,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:38,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:39,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:39,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:40,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:41,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:42,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:43,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:44,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:44,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:44,882 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:08:44,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:08:45,238 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:46,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:47,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:48,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:48,820 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:08:48,821 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:08:48,821 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:08:48,822 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:08:49,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:49,730 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:08:50,025 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:50,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:50,732 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:08:51,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:52,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:53,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:54,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:55,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:08:55,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:56,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:57,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:58,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:59,358 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:08:59,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:08:59,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:08:59,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:09:00,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:01,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:01,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:02,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:03,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:04,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:05,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:06,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:06,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:07,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:08,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:09,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:10,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:11,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:11,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:12,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:13,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:14,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:14,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:09:14,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:09:15,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:16,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:17,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:17,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:18,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:19,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:20,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:21,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:22,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:23,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:23,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:24,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:25,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:26,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:27,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:28,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:28,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:29,359 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:09:29,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:29,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:09:29,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:09:30,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:31,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:32,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:33,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:33,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:34,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:35,586 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:36,587 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:37,587 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:38,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:38,587 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:39,587 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:40,587 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:41,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:42,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:43,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:43,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:44,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:44,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:09:44,883 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:09:45,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:46,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:47,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:48,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:49,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:49,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:50,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:51,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:52,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:53,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:54,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:54,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:55,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:56,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:57,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:58,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:59,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:09:59,362 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:09:59,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:09:59,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:09:59,884 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:10:00,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:10:00,502 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:10:00,502 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:10:00,504 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:10:00,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:00,858 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:10:01,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:02,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:02,861 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:10:03,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:04,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:04,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:05,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:06,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:07,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:08,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:09,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:10,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:10,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:11,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:12,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:13,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:14,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:14,883 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:10:14,884 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:10:15,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:16,054 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:16,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:17,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:18,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:19,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:20,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:21,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:21,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:22,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:23,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:24,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:25,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:26,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:26,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:27,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:28,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:29,363 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:10:29,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:29,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:10:29,884 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:10:30,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:31,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:31,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:32,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:33,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:34,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:35,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:36,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:36,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:37,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:38,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:39,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:40,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:41,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:41,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:42,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:43,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:44,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:44,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:10:44,884 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:10:45,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:46,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:46,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:47,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:48,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:49,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:50,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:51,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:52,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:52,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:53,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:54,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:55,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:56,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:57,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:10:57,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:58,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:59,378 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:10:59,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:10:59,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:10:59,884 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:11:00,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:01,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:02,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:02,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:03,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:04,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:05,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:06,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:07,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:07,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:08,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:09,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:10,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:11,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:12,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:12,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:12,968 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:11:12,969 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:11:12,969 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:11:12,971 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:11:13,069 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:11:13,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:14,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:14,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:11:14,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:11:15,073 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:11:15,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:16,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:17,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:17,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:18,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:19,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:20,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:21,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:22,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:23,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:23,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:24,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:25,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:26,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:27,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:28,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:29,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:29,367 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:11:29,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:29,884 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:11:29,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:11:30,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:31,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:32,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:33,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:34,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:35,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:35,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:36,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:37,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:38,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:39,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:40,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:41,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:41,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:42,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:43,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:44,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:44,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:11:44,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:11:45,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:46,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:47,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:47,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:48,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:49,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:50,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:51,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:52,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:52,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:53,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:54,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:55,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:56,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:57,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:11:57,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:58,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:59,371 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:11:59,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:11:59,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:11:59,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:12:00,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:01,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:02,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:03,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:03,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:04,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:05,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:06,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:07,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:08,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:08,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:09,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:10,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:11,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:12,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:13,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:14,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:14,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:14,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:12:14,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:12:15,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:16,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:17,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:18,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:19,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:19,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:20,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:21,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:22,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:23,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:24,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:24,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:25,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:26,096 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:12:26,097 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:12:26,098 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:12:26,100 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:12:26,133 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:12:26,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:27,136 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:12:27,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:28,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:29,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:29,371 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:12:29,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:29,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:12:29,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:12:30,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:31,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:32,699 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:33,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:34,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:35,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:35,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:36,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:37,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:38,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:39,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:40,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:40,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:41,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:42,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:43,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:44,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:44,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:12:44,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:12:45,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:46,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:46,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:47,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:48,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:49,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:50,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:51,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:51,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:52,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:53,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:54,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:55,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:56,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:57,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:12:57,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:58,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:59,373 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:12:59,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:12:59,885 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:12:59,885 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:13:00,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:01,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:02,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:02,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:03,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:04,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:05,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:06,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:07,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:08,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:08,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:09,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:10,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:11,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:12,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:13,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:14,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:14,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:14,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:13:14,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:13:15,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:16,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:17,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:18,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:19,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:19,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:20,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:21,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:22,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:23,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:24,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:25,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:25,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:26,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:27,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:28,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:29,376 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:13:29,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:29,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:13:29,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:13:30,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:31,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:31,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:32,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:33,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:34,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:35,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:36,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:36,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:37,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:38,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:39,376 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:13:39,377 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:13:39,377 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:13:39,379 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:13:39,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:40,294 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:13:40,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:41,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:41,296 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:13:41,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:42,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:43,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:44,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:44,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:13:44,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:13:45,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:46,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:47,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:47,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:48,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:49,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:50,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:51,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:52,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:52,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:53,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:54,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:55,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:56,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:57,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:58,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:13:58,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:59,379 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:13:59,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:13:59,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:13:59,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:14:00,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:01,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:02,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:03,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:04,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:04,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:05,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:06,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:07,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:08,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:09,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:10,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:10,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:11,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:12,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:13,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:14,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:14,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:14:14,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:14:15,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:16,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:16,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:17,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:18,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:19,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:20,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:21,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:21,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:22,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:23,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:24,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:25,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:26,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:26,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:27,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:28,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:29,381 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:14:29,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:29,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:14:29,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:14:30,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:31,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:32,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:32,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:33,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:34,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:35,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:36,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:37,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:37,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:38,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:39,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:40,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:41,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:42,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:42,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:43,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:44,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:44,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:14:44,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:14:45,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:46,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:47,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:48,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:48,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:49,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:50,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:51,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:51,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:14:51,941 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:14:51,942 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:14:51,944 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:14:52,440 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:14:52,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:53,442 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:14:53,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:53,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:54,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:55,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:56,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:57,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:58,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:59,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:14:59,382 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:14:59,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:14:59,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:14:59,886 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:15:00,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:01,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:02,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:03,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:04,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:04,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:05,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:06,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:07,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:08,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:09,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:10,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:10,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:11,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:12,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:13,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:14,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:14,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:15:14,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:15:15,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:16,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:16,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:17,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:18,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:19,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:20,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:21,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:21,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:22,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:23,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:24,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:25,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:26,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:26,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:27,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:28,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:29,384 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:15:29,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:29,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:15:29,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:15:30,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:31,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:32,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:32,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:33,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:34,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:35,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:36,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:37,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:37,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:38,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:39,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:40,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:41,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:42,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:42,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:43,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:44,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:44,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:15:44,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:15:45,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:46,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:47,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:47,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:48,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:49,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:50,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:51,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:52,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:52,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:53,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:54,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:55,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:56,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:57,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:58,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:15:58,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:59,386 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:15:59,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:15:59,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:15:59,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:16:00,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:01,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:02,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:03,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:04,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:04,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:05,024 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:16:05,025 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:16:05,025 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:16:05,026 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:16:05,619 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:16:05,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:06,770 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:07,623 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:16:07,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:08,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:09,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:09,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:10,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:11,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:12,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:13,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:14,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:14,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:14,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:16:14,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:16:15,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:16,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:17,771 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:18,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:19,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:19,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:20,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:21,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:22,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:23,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:24,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:25,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:25,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:26,772 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:27,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:28,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:29,387 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:16:29,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:29,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:16:29,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:16:30,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:31,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:31,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:32,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:33,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:34,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:35,773 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:36,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:36,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:37,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:38,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:39,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:40,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:41,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:42,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:42,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:43,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:44,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:44,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:16:44,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:16:45,774 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:46,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:47,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:47,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:48,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:49,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:50,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:51,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:52,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:52,775 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:53,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:54,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:55,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:56,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:57,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:16:57,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:58,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:59,389 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:16:59,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:16:59,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:16:59,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:17:00,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:01,776 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:02,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:03,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:03,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:04,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:05,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:06,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:07,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:08,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:08,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:09,777 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:10,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:11,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:12,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:13,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:13,778 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:14,782 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:14,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:17:14,887 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:17:15,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:16,780 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:17,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:17:17,713 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:17:17,713 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:17:17,714 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:17:17,757 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:17:17,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:18,759 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:17:18,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:18,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:19,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:20,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:21,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:22,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:23,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:24,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:24,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:25,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:26,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:27,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:28,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:29,391 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:17:29,393 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:29,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:29,887 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:17:29,888 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:17:30,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:31,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:32,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:33,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:34,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:35,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:35,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:36,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:37,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:38,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:39,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:40,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:40,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:41,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:42,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:43,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:44,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:44,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:17:44,888 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:17:45,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:46,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:46,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:47,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:48,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:49,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:50,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:51,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:51,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:52,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:53,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:54,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:55,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:56,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:17:56,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:57,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:58,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:59,393 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:17:59,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:17:59,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:17:59,888 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:18:00,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:01,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:01,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:02,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:03,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:04,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:05,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:06,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:06,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:07,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:08,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:09,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:10,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:11,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:12,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:12,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:13,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:14,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:14,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:18:14,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:18:15,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:16,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:17,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:17,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:18,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:19,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:20,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:21,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:22,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:22,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:23,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:24,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:25,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:26,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:27,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:27,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:28,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:29,395 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:18:29,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:29,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:18:29,888 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:18:30,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:18:30,273 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:18:30,274 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:18:30,275 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:18:30,904 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:18:30,904 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:18:30,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:31,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:32,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:32,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:33,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:34,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:35,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:36,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:37,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:38,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:38,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:39,931 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:40,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:41,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:42,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:43,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:44,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:44,888 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:18:44,889 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:18:44,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:45,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:46,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:47,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:48,932 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:49,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:50,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:50,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:51,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:52,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:53,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:54,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:55,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:56,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:18:56,933 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:57,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:58,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:18:59,397 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:18:59,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:18:59,889 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:18:59,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:00,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:01,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:01,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:02,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:03,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:04,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:05,934 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:06,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:07,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:07,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:08,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:09,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:10,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:11,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:12,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:12,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:13,935 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:14,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:19:14,889 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:19:14,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:15,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:16,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:17,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:18,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:18,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:19,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:20,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:21,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:22,936 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:23,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:23,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:24,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:25,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:26,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:27,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:28,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:29,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:29,398 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:19:29,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:19:29,889 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:19:29,937 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:30,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:31,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:32,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:33,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:34,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:34,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:35,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:36,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:37,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:38,938 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:39,939 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:40,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:40,939 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:41,939 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:42,939 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:43,008 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:19:43,009 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:19:43,009 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:19:43,013 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:19:43,035 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:19:43,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:44,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:19:44,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:19:44,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:45,039 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:19:45,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:46,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:46,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:47,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:48,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:49,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:50,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:51,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:51,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:52,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:53,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:54,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:55,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:56,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:19:56,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:57,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:58,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:19:59,400 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:19:59,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:19:59,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:19:59,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:00,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:01,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:02,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:02,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:03,941 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:04,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:05,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:06,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:07,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:07,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:08,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:09,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:10,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:11,942 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:12,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:13,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:13,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:14,889 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:20:14,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:20:14,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:15,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:16,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:17,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:18,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:18,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:19,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:20,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:21,943 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:22,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:23,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:23,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:24,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:25,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:26,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:27,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:28,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:28,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:29,402 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:20:29,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:20:29,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:20:29,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:30,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:31,944 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:32,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:33,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:34,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:34,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:35,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:36,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:37,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:38,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:39,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:39,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:40,945 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:41,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:42,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:43,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:44,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:44,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:20:44,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:20:44,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:45,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:46,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:47,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:48,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:49,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:49,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:50,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:51,946 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:52,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:53,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:54,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:54,947 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:55,384 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:20:55,385 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:20:55,386 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:20:55,389 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:20:55,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:56,170 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:20:56,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:57,174 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:20:57,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:58,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:20:59,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:20:59,402 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:20:59,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:20:59,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:20:59,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:00,954 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:01,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:02,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:03,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:04,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:05,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:05,955 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:06,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:07,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:08,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:09,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:10,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:11,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:11,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:12,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:13,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:14,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:21:14,890 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:21:14,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:15,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:16,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:16,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:17,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:18,956 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:19,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:20,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:21,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:22,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:22,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:23,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:24,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:25,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:26,957 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:27,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:27,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:28,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:29,404 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:21:29,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:21:29,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:21:29,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:30,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:31,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:32,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:32,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:33,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:34,958 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:35,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:36,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:37,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:37,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:38,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:39,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:40,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:41,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:42,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:43,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:43,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:44,890 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:21:44,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:21:44,959 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:45,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:46,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:47,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:48,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:48,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:49,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:50,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:51,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:52,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:53,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:53,960 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:54,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:55,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:56,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:57,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:58,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:21:59,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:21:59,405 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:21:59,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:21:59,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:21:59,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:00,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:01,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:02,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:03,961 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:05,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:05,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:06,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:07,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:07,636 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:22:07,637 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:22:07,637 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:22:07,641 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:22:08,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:08,313 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:22:09,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:09,315 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:22:10,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:10,677 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:11,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:12,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:13,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:14,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:14,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:22:14,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:22:15,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:16,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:16,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:17,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:18,246 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:19,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:20,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:21,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:21,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:22,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:23,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:24,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:25,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:26,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:26,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:27,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:28,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:29,247 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:29,406 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:22:29,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:22:29,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:22:30,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:31,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:31,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:32,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:33,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:34,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:35,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:36,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:36,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:37,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:38,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:39,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:40,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:41,248 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:42,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:42,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:43,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:44,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:44,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:22:44,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:22:45,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:46,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:47,187 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:47,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:48,249 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:49,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:50,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:51,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:52,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:52,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:53,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:54,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:55,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:56,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:57,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:22:57,250 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:58,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:59,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:22:59,409 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:22:59,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:22:59,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:23:00,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:01,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:02,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:03,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:03,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:04,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:05,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:06,251 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:07,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:08,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:08,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:09,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:10,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:11,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:12,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:13,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:13,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:14,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:14,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:23:14,891 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:23:15,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:16,252 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:17,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:18,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:19,188 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:19,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:19,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:23:19,605 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:23:19,605 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:23:19,608 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:23:20,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:20,455 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:23:21,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:21,456 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:23:22,253 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:23,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:24,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:24,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:25,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:26,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:27,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:28,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:29,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:29,411 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:23:29,413 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:29,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:23:29,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:23:30,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:31,254 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:32,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:33,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:34,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:35,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:35,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:36,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:37,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:38,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:39,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:40,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:40,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:41,255 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:42,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:43,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:44,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:44,891 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:23:44,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:23:45,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:46,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:46,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:47,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:48,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:49,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:50,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:51,189 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:51,256 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:52,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:53,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:54,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:55,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:56,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:23:56,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:57,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:58,257 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:59,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:23:59,413 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:23:59,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:23:59,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:24:00,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:01,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:02,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:02,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:03,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:04,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:05,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:06,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:07,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:07,258 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:08,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:09,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:10,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:11,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:12,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:12,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:13,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:14,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:14,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:24:14,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:24:15,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:16,259 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:17,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:18,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:18,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:19,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:20,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:21,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:22,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:23,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:24,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:24,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:25,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:26,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:27,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:28,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:29,190 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:29,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:29,414 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:24:29,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:24:29,892 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:24:30,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:31,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:32,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:33,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:24:33,065 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:24:33,065 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:24:33,068 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:24:33,261 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:33,624 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:24:34,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:35,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:35,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:35,627 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:24:36,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:37,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:38,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:39,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:40,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:40,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:41,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:42,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:43,262 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:44,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:44,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:24:44,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:24:45,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:46,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:46,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:47,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:48,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:49,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:50,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:51,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:51,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:52,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:53,263 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:54,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:55,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:56,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:57,191 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:24:57,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:58,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:59,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:24:59,416 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:24:59,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:24:59,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:25:00,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:01,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:02,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:02,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:03,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:04,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:05,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:06,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:07,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:07,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:08,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:09,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:10,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:11,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:12,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:13,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:13,265 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:14,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:14,892 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:25:14,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:25:15,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:16,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:17,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:18,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:18,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:19,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:20,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:21,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:22,266 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:23,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:24,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:24,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:25,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:26,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:27,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:28,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:29,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:29,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:29,418 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:25:29,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:25:29,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:25:30,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:31,267 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:32,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:33,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:34,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:35,192 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:35,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:36,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:37,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:38,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:39,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:40,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:40,268 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:41,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:42,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:43,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:44,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:44,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:25:44,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:25:45,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:25:45,186 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:25:45,186 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:25:45,190 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:25:45,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:45,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:45,750 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:25:46,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:47,269 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:47,753 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:25:48,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:49,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:50,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:51,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:51,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:52,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:53,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:54,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:55,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:56,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:25:56,270 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:57,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:58,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:59,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:25:59,418 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:25:59,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:25:59,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:26:00,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:01,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:01,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:02,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:03,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:04,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:05,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:06,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:06,271 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:07,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:08,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:09,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:10,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:11,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:12,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:12,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:13,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:14,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:14,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:26:14,893 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:26:15,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:16,272 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:17,193 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:17,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:18,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:19,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:20,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:21,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:22,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:22,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:23,273 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:24,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:25,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:26,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:27,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:27,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:28,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:29,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:29,420 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:26:29,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:26:29,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:26:30,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:31,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:32,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:33,194 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:33,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:34,274 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:35,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:36,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:37,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:38,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:38,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:39,275 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:40,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:41,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:42,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:43,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:44,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:44,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:44,893 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:26:44,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:26:45,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:46,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:47,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:48,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:49,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:50,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:50,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:51,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:52,276 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:53,277 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:54,277 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:55,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:26:55,277 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:56,278 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:57,277 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:58,277 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:58,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:26:58,713 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:26:58,713 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:26:58,717 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:26:58,880 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:26:59,423 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:26:59,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:26:59,881 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:26:59,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:26:59,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:27:00,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:01,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:01,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:02,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:03,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:04,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:05,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:06,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:06,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:07,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:08,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:09,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:10,700 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:11,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:11,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:12,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:13,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:14,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:14,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:27:14,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:27:15,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:16,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:17,195 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:17,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:18,701 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:19,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:20,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:21,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:22,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:22,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:23,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:24,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:25,702 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:26,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:27,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:27,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:28,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:29,423 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:27:29,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:29,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:27:29,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:27:30,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:31,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:32,703 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:33,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:33,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:34,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:35,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:36,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:37,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:38,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:38,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:39,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:40,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:41,704 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:42,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:43,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:43,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:44,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:44,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:27:44,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:27:45,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:46,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:47,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:48,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:49,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:49,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:50,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:51,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:52,705 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:53,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:54,196 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:54,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:55,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:56,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:57,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:58,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:59,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:27:59,424 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:27:59,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:27:59,894 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:27:59,894 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:28:00,706 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:01,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:02,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:03,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:04,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:04,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:05,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:06,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:07,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:08,707 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:09,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:10,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:10,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:11,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:11,792 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:28:11,793 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:28:11,793 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:28:11,796 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:28:12,022 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:28:12,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:13,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:14,026 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:28:14,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:14,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:28:14,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:28:15,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:16,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:16,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:17,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:18,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:19,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:20,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:21,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:21,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:22,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:23,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:24,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:25,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:26,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:26,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:27,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:28,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:29,426 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:28:29,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:29,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:28:29,895 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:28:30,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:31,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:32,197 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:32,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:33,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:34,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:35,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:36,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:37,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:37,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:38,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:39,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:40,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:41,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:42,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:43,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:43,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:44,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:44,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:28:44,895 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:28:45,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:46,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:47,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:48,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:48,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:49,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:50,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:51,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:52,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:53,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:54,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:54,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:55,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:56,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:57,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:58,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:59,198 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:28:59,428 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:28:59,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:28:59,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:28:59,895 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:29:00,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:01,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:02,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:03,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:04,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:04,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:05,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:06,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:07,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:08,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:09,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:09,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:10,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:11,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:12,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:13,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:14,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:14,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:29:14,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:29:15,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:15,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:16,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:17,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:18,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:19,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:20,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:20,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:21,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:22,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:23,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:23,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:29:23,909 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:29:23,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:29:23,913 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:29:24,160 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:29:24,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:25,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:25,913 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:26,163 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:29:26,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:27,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:28,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:29,429 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:29:29,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:29,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:29:29,895 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:29:30,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:31,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:31,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:32,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:33,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:34,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:35,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:36,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:36,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:37,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:38,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:39,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:40,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:41,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:42,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:42,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:43,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:44,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:44,895 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:29:44,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:29:45,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:46,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:47,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:47,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:48,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:49,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:50,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:51,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:52,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:53,199 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:53,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:54,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:55,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:56,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:57,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:58,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:59,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:29:59,431 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:29:59,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:29:59,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:29:59,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:30:00,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:01,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:02,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:03,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:04,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:05,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:05,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:06,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:07,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:08,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:09,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:10,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:10,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:11,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:12,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:13,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:14,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:14,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:30:14,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:30:15,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:16,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:16,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:17,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:18,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:19,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:20,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:21,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:21,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:22,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:23,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:24,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:25,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:26,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:26,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:27,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:28,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:29,433 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:30:29,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:29,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:30:29,896 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:30:30,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:31,200 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:31,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:32,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:33,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:34,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:35,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:36,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:36,260 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:30:36,262 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:30:36,262 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:30:36,267 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:30:36,308 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:30:36,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:37,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:38,311 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:30:38,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:39,921 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:40,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:41,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:41,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:42,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:43,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:44,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:30:44,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:30:44,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:45,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:46,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:47,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:47,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:48,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:49,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:50,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:51,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:52,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:53,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:53,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:54,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:55,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:56,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:57,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:58,201 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:30:58,923 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:30:59,435 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:30:59,896 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:30:59,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:30:59,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:00,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:01,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:02,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:03,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:03,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:04,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:05,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:06,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:07,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:08,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:09,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:09,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:10,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:11,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:12,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:13,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:14,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:31:14,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:31:14,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:15,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:15,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:16,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:17,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:18,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:19,925 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:20,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:20,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:21,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:22,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:23,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:24,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:25,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:25,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:26,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:27,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:28,926 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:29,436 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:31:29,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:31:29,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:31:29,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:30,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:31,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:31,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:32,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:33,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:34,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:35,927 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:36,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:36,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:37,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:38,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:39,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:40,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:41,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:41,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:42,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:43,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:44,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:31:44,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:31:44,940 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:45,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:46,202 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:47,137 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:48,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:49,135 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:49,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:31:49,481 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:31:49,481 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:31:49,497 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:31:50,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:50,459 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:31:51,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:51,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:51,461 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:31:52,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:53,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:54,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:55,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:56,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:57,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:57,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:31:58,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:59,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:31:59,439 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:31:59,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:31:59,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:32:00,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:01,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:02,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:03,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:03,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:04,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:05,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:06,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:07,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:08,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:08,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:09,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:10,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:11,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:12,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:13,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:14,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:14,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:14,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:32:14,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:32:15,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:16,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:17,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:18,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:19,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:20,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:20,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:21,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:22,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:23,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:24,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:25,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:25,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:26,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:27,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:28,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:29,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:29,439 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:32:29,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:32:29,897 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:32:30,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:31,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:31,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:32,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:33,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:34,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:35,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:36,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:36,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:37,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:38,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:39,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:40,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:41,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:42,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:42,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:43,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:44,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:44,897 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:32:44,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:32:45,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:46,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:47,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:47,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:48,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:49,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:50,169 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:51,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:52,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:52,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:53,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:54,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:55,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:56,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:57,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:58,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:58,204 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:32:59,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:32:59,441 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:32:59,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:32:59,899 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:33:00,170 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:01,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:01,876 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:33:01,877 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:33:01,877 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:33:01,881 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:33:02,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:02,618 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:33:03,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:03,622 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:33:03,886 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:04,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:05,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:06,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:07,171 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:08,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:09,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:09,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:10,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:11,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:12,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:13,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:14,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:14,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:33:14,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:33:15,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:15,172 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:16,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:17,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:18,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:19,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:20,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:20,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:21,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:22,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:23,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:24,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:25,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:25,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:26,173 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:27,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:28,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:29,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:29,450 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:33:29,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:33:29,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:33:30,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:31,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:31,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:32,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:33,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:34,174 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:35,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:36,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:36,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:37,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:38,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:39,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:40,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:41,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:42,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:42,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:43,175 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:44,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:44,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:33:44,898 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:33:45,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:46,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:47,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:48,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:48,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:49,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:50,176 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:51,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:52,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:53,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:53,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:54,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:55,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:56,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:57,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:58,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:58,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:33:59,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:33:59,451 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:33:59,898 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:33:59,899 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:34:00,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:01,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:02,177 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:03,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:04,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:04,205 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:05,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:06,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:07,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:08,178 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:09,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:09,206 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:10,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:11,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:12,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:13,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:14,048 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:34:14,049 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:34:14,049 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:34:14,053 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:34:14,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:14,754 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:34:14,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:34:14,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:34:15,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:15,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:15,756 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:34:16,179 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:17,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:18,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:19,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:20,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:20,206 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:21,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:22,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:23,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:24,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:25,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:25,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:26,180 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:27,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:28,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:29,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:29,453 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:34:29,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:34:29,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:34:30,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:31,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:31,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:32,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:33,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:34,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:35,181 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:36,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:36,206 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:37,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:38,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:39,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:40,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:41,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:41,206 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:42,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:43,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:44,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:44,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:34:44,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:34:45,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:46,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:47,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:47,206 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:48,182 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:49,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:50,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:51,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:52,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:53,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:53,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:54,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:55,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:56,183 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:57,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:58,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:58,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:34:59,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:34:59,458 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:34:59,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:34:59,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:35:00,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:01,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:02,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:03,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:04,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:04,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:05,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:06,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:07,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:08,184 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:09,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:09,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:10,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:11,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:12,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:13,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:14,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:14,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:14,899 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:35:14,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:35:15,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:16,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:17,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:18,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:19,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:20,185 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:20,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:21,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:22,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:23,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:24,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:25,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:25,207 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:26,186 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:26,548 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:35:26,549 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:35:26,549 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:35:26,553 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:35:26,907 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:35:27,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:27,909 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:35:28,329 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:29,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:29,459 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:35:29,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:35:29,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:35:30,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:31,006 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:31,329 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:32,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:33,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:34,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:35,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:36,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:36,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:37,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:38,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:39,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:40,330 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:41,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:41,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:42,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:43,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:44,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:44,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:35:44,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:35:45,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:46,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:47,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:47,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:48,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:49,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:50,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:51,331 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:52,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:52,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:53,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:54,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:55,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:56,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:57,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:35:57,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:58,332 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:59,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:35:59,461 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:35:59,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:35:59,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:36:00,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:01,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:02,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:02,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:03,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:04,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:05,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:06,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:07,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:08,208 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:08,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:09,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:10,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:11,333 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:12,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:13,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:13,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:14,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:14,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:36:14,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:36:15,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:16,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:17,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:18,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:19,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:19,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:20,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:21,334 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:22,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:23,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:24,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:25,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:25,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:26,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:27,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:28,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:29,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:29,462 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:36:29,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:36:29,900 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:36:30,335 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:31,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:31,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:32,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:33,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:34,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:35,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:36,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:36,336 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:37,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:38,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:39,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:36:39,169 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:36:39,169 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:36:39,173 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:36:39,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:40,049 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:36:40,049 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:36:40,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:41,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:41,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:42,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:43,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:44,337 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:44,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:36:44,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:36:45,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:46,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:47,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:47,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:48,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:49,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:50,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:51,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:52,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:52,338 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:53,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:54,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:55,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:56,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:57,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:36:57,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:58,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:59,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:36:59,464 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:36:59,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:36:59,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:37:00,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:01,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:02,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:03,209 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:03,339 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:04,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:05,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:06,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:07,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:08,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:08,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:09,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:10,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:11,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:12,340 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:13,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:13,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:14,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:14,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:37:14,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:37:15,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:16,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:17,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:18,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:18,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:19,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:20,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:21,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:22,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:23,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:24,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:24,341 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:25,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:26,342 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:27,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:28,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:29,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:29,466 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:37:29,468 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:29,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:37:29,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:37:30,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:31,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:32,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:33,343 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:34,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:35,210 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:35,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:36,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:37,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:38,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:39,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:40,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:40,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:41,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:42,344 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:43,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:44,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:44,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:37:44,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:37:45,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:46,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:46,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:47,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:48,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:49,346 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:50,345 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:51,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:51,203 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:37:51,205 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:37:51,205 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:37:51,210 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:37:51,346 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:52,179 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:37:52,179 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:37:52,347 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:53,346 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:54,346 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:55,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:56,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:37:56,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:57,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:58,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:59,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:37:59,468 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:37:59,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:37:59,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:38:00,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:01,348 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:02,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:02,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:03,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:04,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:05,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:06,349 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:07,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:07,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:08,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:09,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:10,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:11,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:12,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:12,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:13,350 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:14,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:14,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:38:14,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:38:15,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:16,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:17,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:18,211 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:18,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:19,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:20,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:21,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:22,351 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:23,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:23,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:24,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:25,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:26,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:27,352 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:28,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:28,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:29,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:29,471 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:38:29,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:38:29,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:38:30,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:31,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:32,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:33,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:34,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:34,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:35,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:36,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:37,353 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:38,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:39,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:39,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:40,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:41,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:42,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:43,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:44,212 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:44,354 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:44,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:38:44,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:38:45,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:46,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:47,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:48,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:49,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:49,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:50,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:51,355 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:52,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:53,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:54,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:55,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:38:55,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:56,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:57,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:58,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:59,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:38:59,471 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:38:59,901 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:38:59,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:39:00,356 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:01,007 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:01,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:02,357 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:03,358 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:03,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:39:03,709 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:39:03,709 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:39:03,712 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:39:04,332 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:39:04,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:05,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:06,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:06,335 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:39:06,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:07,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:08,414 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:09,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:10,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:11,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:11,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:12,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:13,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:14,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:14,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:39:14,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:39:15,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:16,415 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:17,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:17,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:18,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:19,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:20,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:21,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:22,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:22,416 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:23,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:24,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:25,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:26,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:27,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:27,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:28,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:29,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:29,473 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:39:29,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:39:29,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:39:30,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:31,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:32,417 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:33,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:33,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:34,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:35,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:36,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:37,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:38,213 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:38,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:39,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:40,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:41,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:42,418 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:43,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:43,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:44,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:44,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:39:44,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:39:45,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:46,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:47,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:48,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:49,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:49,419 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:50,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:51,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:52,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:53,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:54,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:54,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:55,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:56,420 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:57,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:58,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:59,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:39:59,475 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:39:59,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:39:59,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:39:59,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:40:00,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:01,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:02,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:03,421 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:04,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:05,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:05,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:06,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:07,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:08,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:09,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:10,422 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:11,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:11,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:12,423 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:13,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:14,437 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:14,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:40:14,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:40:15,438 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:15,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:40:15,842 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:40:15,842 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:40:15,846 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:40:16,214 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:16,469 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:40:16,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:17,476 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:18,473 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:40:18,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:19,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:20,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:21,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:21,477 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:22,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:23,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:24,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:25,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:26,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:27,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:27,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:28,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:29,476 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:40:29,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:29,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:40:29,902 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:40:30,478 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:31,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:32,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:32,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:33,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:34,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:35,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:36,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:37,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:38,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:38,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:39,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:40,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:41,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:42,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:43,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:43,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:44,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:44,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:40:44,903 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:40:45,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:46,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:47,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:48,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:49,215 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:49,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:50,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:51,480 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:52,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:53,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:54,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:54,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:55,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:56,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:57,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:58,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:59,477 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:40:59,479 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:40:59,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:40:59,902 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:40:59,903 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:41:00,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:01,481 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:02,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:03,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:04,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:05,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:05,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:06,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:07,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:08,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:09,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:10,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:10,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:11,482 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:12,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:13,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:14,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:14,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:41:14,903 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:41:15,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:16,009 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:16,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:17,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:18,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:19,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:20,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:21,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:21,483 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:22,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:23,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:24,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:25,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:26,216 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:26,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:27,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:27,696 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:41:27,697 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:41:27,698 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:41:27,701 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:41:28,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:28,627 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:41:29,480 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:41:29,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:29,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:41:29,903 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:41:30,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:30,630 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:41:31,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:31,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:32,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:33,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:34,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:35,485 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:36,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:37,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:37,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:38,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:39,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:40,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:41,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:42,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:42,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:43,486 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:44,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:44,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:41:44,903 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:41:45,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:46,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:47,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:48,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:48,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:49,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:50,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:51,487 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:52,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:53,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:54,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:54,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:55,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:56,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:57,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:58,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:59,481 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:41:59,484 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:41:59,488 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:41:59,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:41:59,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:42:00,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:01,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:02,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:03,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:04,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:05,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:05,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:06,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:07,489 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:08,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:09,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:10,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:11,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:11,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:12,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:13,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:14,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:14,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:42:14,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:42:15,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:16,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:17,217 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:17,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:18,490 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:19,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:20,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:21,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:22,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:22,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:23,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:24,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:25,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:26,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:27,491 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:28,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:28,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:29,483 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:42:29,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:29,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:42:29,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:42:30,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:31,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:32,492 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:33,218 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:33,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:34,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:35,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:36,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:37,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:38,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:38,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:39,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:40,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:42:40,169 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:42:40,169 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:42:40,172 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:42:40,493 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:40,765 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:42:41,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:42,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:42,768 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:42:43,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:44,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:44,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:44,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:42:44,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:42:45,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:46,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:47,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:48,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:49,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:50,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:50,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:51,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:52,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:53,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:54,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:55,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:56,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:42:56,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:57,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:58,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:59,485 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:42:59,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:42:59,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:42:59,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:43:00,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:01,219 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:01,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:02,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:03,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:04,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:05,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:06,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:06,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:07,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:08,496 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:09,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:10,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:11,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:11,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:12,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:13,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:14,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:14,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:43:14,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:43:15,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:16,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:17,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:17,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:18,497 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:19,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:20,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:21,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:22,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:22,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:23,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:24,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:25,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:26,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:27,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:28,220 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:28,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:29,486 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:43:29,498 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:29,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:43:29,904 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:43:30,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:31,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:32,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:33,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:34,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:34,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:35,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:36,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:37,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:38,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:39,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:40,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:40,499 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:41,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:42,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:43,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:44,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:44,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:43:44,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:43:45,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:46,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:46,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:47,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:48,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:49,500 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:50,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:51,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:51,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:52,264 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:43:52,265 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:43:52,265 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:43:52,269 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:43:52,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:52,899 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:43:53,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:53,901 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:43:54,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:55,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:56,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:43:56,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:57,501 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:58,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:59,489 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:43:59,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:43:59,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:43:59,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:44:00,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:01,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:01,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:02,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:03,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:04,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:05,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:06,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:07,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:07,502 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:08,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:09,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:10,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:11,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:12,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:13,221 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:13,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:14,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:14,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:44:14,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:44:15,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:16,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:17,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:18,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:18,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:19,503 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:20,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:21,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:22,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:23,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:23,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:24,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:25,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:26,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:27,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:28,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:28,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:29,490 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:44:29,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:29,904 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:44:29,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:44:30,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:31,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:32,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:33,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:34,222 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:34,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:35,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:36,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:37,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:38,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:39,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:39,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:40,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:41,505 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:42,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:43,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:44,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:44,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:44:44,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:44:45,010 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:45,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:46,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:47,506 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:48,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:49,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:50,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:50,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:51,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:52,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:53,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:54,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:55,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:56,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:44:56,507 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:57,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:58,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:59,492 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:44:59,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:44:59,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:44:59,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:45:00,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:01,508 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:02,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:02,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:03,509 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:04,440 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:45:04,441 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:45:04,442 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:45:04,445 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:45:04,578 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:05,036 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:45:05,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:06,038 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:45:06,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:07,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:07,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:08,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:09,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:10,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:11,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:12,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:13,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:13,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:14,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:14,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:45:14,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:45:15,579 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:16,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:17,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:18,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:18,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:19,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:20,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:21,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:22,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:23,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:23,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:24,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:25,580 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:26,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:27,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:28,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:28,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:29,493 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:45:29,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:29,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:45:29,905 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:45:30,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:31,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:32,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:33,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:34,223 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:34,581 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:35,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:36,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:37,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:38,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:39,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:39,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:40,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:41,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:42,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:43,582 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:44,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:44,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:45:44,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:45:45,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:45,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:46,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:47,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:48,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:49,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:50,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:50,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:51,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:52,583 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:53,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:54,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:55,224 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:45:55,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:56,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:57,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:58,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:59,495 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:45:59,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:45:59,905 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:45:59,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:46:00,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:01,011 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:01,584 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:02,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:03,585 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:04,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:05,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:06,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:06,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:07,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:08,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:09,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:10,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:11,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:12,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:12,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:13,588 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:14,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:14,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:46:14,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:46:15,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:16,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:16,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:46:16,829 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:46:16,829 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:46:16,831 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:46:17,168 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:46:17,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:17,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:18,170 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:46:18,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:19,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:20,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:21,589 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:22,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:23,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:23,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:24,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:25,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:26,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:27,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:28,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:28,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:29,497 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:46:29,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:29,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:46:29,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:46:30,590 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:31,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:32,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:33,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:34,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:34,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:35,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:36,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:37,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:38,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:39,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:40,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:40,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:41,591 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:42,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:43,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:44,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:44,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:46:44,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:46:45,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:46,012 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:46,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:47,592 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:48,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:49,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:50,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:51,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:51,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:52,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:53,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:54,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:55,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:56,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:46:56,593 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:57,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:58,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:59,498 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:46:59,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:46:59,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:46:59,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:47:00,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:01,225 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:01,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:02,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:03,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:04,594 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:05,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:06,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:06,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:07,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:08,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:09,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:10,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:11,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:11,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:12,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:13,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:14,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:14,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:47:14,906 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:47:15,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:16,595 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:17,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:17,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:18,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:19,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:20,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:21,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:22,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:22,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:23,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:24,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:25,596 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:26,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:27,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:27,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:28,364 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:47:28,365 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:47:28,365 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:47:28,367 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:47:28,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:29,319 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:47:29,500 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:47:29,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:29,906 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:47:29,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:47:30,321 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:47:30,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:31,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:32,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:33,226 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:33,597 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:34,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:35,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:36,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:37,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:38,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:38,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:39,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:40,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:41,598 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:42,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:43,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:44,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:44,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:44,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:47:44,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:47:45,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:46,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:47,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:48,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:49,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:50,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:50,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:51,599 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:52,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:53,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:54,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:55,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:56,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:47:56,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:57,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:58,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:59,502 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:47:59,600 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:47:59,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:47:59,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:48:00,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:01,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:01,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:02,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:03,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:04,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:05,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:06,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:06,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:07,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:08,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:09,601 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:10,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:11,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:12,227 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:12,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:13,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:14,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:14,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:48:14,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:48:15,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:16,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:17,602 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:18,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:18,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:19,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:20,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:21,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:22,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:23,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:24,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:24,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:25,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:26,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:27,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:28,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:29,503 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:48:29,504 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:29,603 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:29,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:48:29,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:48:30,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:31,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:32,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:33,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:34,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:35,228 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:35,604 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:36,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:37,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:38,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:39,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:39,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:48:39,925 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:48:39,925 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:48:39,927 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:48:40,447 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:48:40,448 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:48:40,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:40,928 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:41,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:42,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:43,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:44,605 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:44,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:48:44,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:48:45,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:46,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:46,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:47,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:48,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:49,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:50,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:51,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:51,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:52,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:53,606 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:54,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:55,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:56,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:48:56,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:57,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:58,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:59,504 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:48:59,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:48:59,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:48:59,907 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:49:00,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:01,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:01,607 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:02,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:03,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:04,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:05,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:06,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:06,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:07,608 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:08,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:09,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:10,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:11,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:11,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:12,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:13,609 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:14,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:14,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:49:14,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:49:15,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:16,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:17,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:17,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:18,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:19,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:20,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:21,610 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:22,229 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:22,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:23,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:24,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:25,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:26,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:27,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:27,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:28,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:29,506 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:49:29,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:29,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:49:29,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:49:30,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:31,611 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:32,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:33,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:33,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:34,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:35,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:36,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:37,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:38,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:38,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:39,612 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:40,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:41,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:42,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:43,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:43,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:44,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:44,907 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:49:44,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:49:45,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:46,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:47,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:48,230 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:48,613 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:49,693 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:50,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:51,687 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:52,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:49:52,069 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:49:52,070 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:49:52,071 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:49:52,600 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:49:52,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:53,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:54,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:54,603 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:49:54,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:55,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:56,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:57,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:58,708 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:59,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:49:59,508 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:49:59,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:49:59,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:49:59,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:50:00,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:01,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:02,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:03,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:04,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:04,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:05,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:06,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:07,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:08,709 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:09,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:10,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:10,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:11,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:12,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:13,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:14,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:14,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:50:14,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:50:15,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:16,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:16,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:17,710 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:18,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:19,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:20,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:21,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:21,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:22,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:23,711 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:24,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:25,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:26,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:26,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:27,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:28,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:29,509 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:50:29,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:29,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:50:29,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:50:30,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:31,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:31,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:32,712 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:33,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:34,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:35,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:36,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:37,231 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:37,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:38,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:39,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:40,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:41,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:42,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:42,713 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:43,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:44,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:44,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:50:44,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:50:45,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:46,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:47,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:48,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:48,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:49,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:50,714 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:51,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:52,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:53,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:54,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:54,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:55,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:56,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:57,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:58,715 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:59,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:50:59,510 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:50:59,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:50:59,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:50:59,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:51:00,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:01,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:02,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:03,716 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:03,900 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:51:03,901 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:51:03,901 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:51:03,902 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:51:04,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:04,734 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:51:04,734 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:51:04,903 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:05,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:06,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:07,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:08,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:09,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:10,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:10,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:11,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:12,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:13,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:14,717 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:14,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:51:14,908 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:51:15,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:16,013 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:16,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:17,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:18,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:19,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:20,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:21,232 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:21,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:22,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:23,718 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:24,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:25,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:26,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:26,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:27,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:28,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:29,512 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:51:29,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:29,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:51:29,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:51:30,719 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:31,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:31,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:32,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:33,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:34,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:35,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:36,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:36,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:37,720 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:38,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:39,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:40,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:41,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:42,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:42,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:43,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:44,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:44,908 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:51:44,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:51:45,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:46,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:47,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:48,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:48,721 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:49,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:50,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:51,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:52,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:53,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:53,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:54,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:55,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:56,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:57,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:58,233 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:51:58,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:59,513 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:51:59,722 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:51:59,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:51:59,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:52:00,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:01,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:02,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:03,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:03,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:04,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:05,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:06,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:07,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:08,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:08,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:09,723 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:10,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:11,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:12,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:13,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:14,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:14,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:14,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:52:14,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:52:15,430 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:52:15,431 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:52:15,431 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:52:15,432 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:52:15,724 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:15,862 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:52:16,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:16,864 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:52:17,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:18,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:19,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:19,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:20,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:21,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:22,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:23,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:24,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:25,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:25,725 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:26,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:27,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:28,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:29,515 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:52:29,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:29,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:52:29,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:52:30,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:31,014 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:31,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:32,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:33,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:34,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:35,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:36,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:36,726 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:37,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:38,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:39,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:40,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:41,234 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:41,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:42,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:43,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:44,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:44,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:52:44,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:52:45,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:46,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:46,727 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:47,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:48,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:49,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:50,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:51,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:51,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:52,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:53,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:54,728 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:55,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:56,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:57,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:52:57,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:58,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:59,516 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:52:59,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:52:59,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:52:59,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:53:00,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:01,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:02,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:03,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:03,729 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:04,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:05,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:06,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:07,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:08,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:08,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:09,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:10,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:11,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:12,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:13,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:14,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:14,730 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:14,909 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:53:14,909 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:53:15,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:16,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:17,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:18,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:19,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:20,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:20,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:21,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:22,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:23,731 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:24,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:25,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:25,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:26,827 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:27,144 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:53:27,145 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:53:27,145 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:53:27,147 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:53:27,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:27,981 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:53:28,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:28,983 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:53:29,517 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:53:29,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:29,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:53:29,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:53:30,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:31,015 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:31,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:32,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:33,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:34,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:35,828 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:36,235 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:36,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:37,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:38,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:39,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:40,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:41,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:41,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:42,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:43,829 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:44,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:44,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:53:44,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:53:45,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:46,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:46,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:47,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:48,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:49,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:50,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:51,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:52,236 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:52,830 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:53,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:54,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:55,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:56,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:57,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:58,245 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:53:58,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:59,520 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:53:59,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:53:59,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:53:59,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:54:00,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:01,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:02,831 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:03,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:04,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:04,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:05,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:06,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:07,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:08,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:09,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:10,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:10,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:11,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:12,832 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:13,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:14,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:14,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:54:14,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:54:15,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:16,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:16,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:17,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:18,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:19,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:20,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:21,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:21,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:22,833 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:23,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:24,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:25,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:26,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:27,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:27,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:28,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:29,522 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:54:29,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:29,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:54:29,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:54:30,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:31,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:32,237 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:32,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:33,834 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:34,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:35,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:36,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:37,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:37,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:38,732 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:54:38,733 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:54:38,733 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:54:38,735 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:54:38,835 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:39,101 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:54:39,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:40,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:41,104 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:54:41,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:42,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:43,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:43,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:44,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:44,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:54:44,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:54:45,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:46,836 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:47,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:48,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:49,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:49,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:50,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:51,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:52,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:53,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:54,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:55,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:54:55,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:56,837 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:57,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:58,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:59,523 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:54:59,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:54:59,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:54:59,910 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:55:00,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:01,016 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:01,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:02,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:03,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:04,838 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:05,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:06,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:06,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:07,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:08,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:09,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:10,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:11,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:11,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:12,839 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:13,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:14,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:14,910 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:55:14,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:55:15,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:16,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:16,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:17,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:18,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:19,840 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:20,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:21,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:21,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:22,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:23,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:24,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:25,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:26,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:26,841 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:27,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:28,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:29,524 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:55:29,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:29,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:55:29,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:55:30,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:31,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:31,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:32,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:33,842 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:34,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:35,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:36,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:37,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:37,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:38,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:39,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:40,843 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:41,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:42,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:42,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:43,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:44,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:44,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:55:44,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:55:45,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:46,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:47,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:47,844 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:48,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:49,845 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:50,448 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:55:50,449 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:55:50,449 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:55:50,451 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:55:51,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:51,235 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:55:52,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:52,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:53,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:53,239 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:55:54,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:55,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:56,057 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:57,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:58,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:58,449 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:55:59,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:55:59,526 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:55:59,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:55:59,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:56:00,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:01,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:02,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:03,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:04,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:04,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:05,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:06,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:07,058 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:08,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:09,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:09,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:10,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:11,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:12,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:13,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:14,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:14,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:56:14,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:56:15,027 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:15,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:16,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:17,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:18,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:19,059 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:20,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:20,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:21,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:22,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:23,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:24,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:25,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:25,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:26,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:27,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:28,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:29,060 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:29,527 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:56:29,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:56:29,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:56:30,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:31,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:31,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:32,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:33,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:34,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:35,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:36,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:36,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:37,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:38,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:39,061 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:40,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:41,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:41,450 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:42,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:43,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:44,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:44,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:56:44,911 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:56:45,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:46,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:46,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:47,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:48,062 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:49,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:50,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:51,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:52,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:52,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:53,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:54,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:55,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:56,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:57,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:57,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:56:58,063 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:59,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:56:59,528 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:56:59,911 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:56:59,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:57:00,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:01,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:02,076 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:57:02,077 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:02,077 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:57:02,077 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:57:02,079 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:57:02,372 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:57:03,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:03,079 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:03,373 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:57:04,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:05,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:05,377 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:57:06,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:07,064 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:08,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:08,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:09,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:10,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:11,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:12,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:13,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:13,451 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:14,065 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:14,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:57:14,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:57:15,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:16,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:17,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:18,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:19,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:19,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:20,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:21,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:22,066 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:23,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:24,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:24,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:25,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:26,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:27,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:28,067 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:29,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:29,531 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:57:29,532 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:29,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:57:29,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:57:30,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:31,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:32,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:33,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:34,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:35,068 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:35,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:36,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:37,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:38,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:39,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:40,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:40,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:41,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:42,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:43,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:44,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:44,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:57:44,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:57:45,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:46,028 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:46,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:47,069 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:48,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:49,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:50,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:51,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:51,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:52,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:53,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:54,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:55,070 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:56,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:56,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:57:57,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:58,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:59,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:57:59,531 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:57:59,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:57:59,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:58:00,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:01,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:01,452 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:02,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:03,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:04,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:05,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:06,071 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:06,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:07,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:08,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:09,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:10,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:11,072 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:11,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:12,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:13,073 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:14,108 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:58:14,109 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:58:14,109 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:58:14,111 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:58:14,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:14,499 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:58:14,499 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:58:14,913 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:58:14,914 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:58:15,159 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:16,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:16,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:16,502 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:58:17,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:18,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:19,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:20,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:21,160 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:22,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:22,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:23,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:24,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:25,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:26,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:27,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:27,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:28,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:29,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:29,533 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:58:29,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:58:29,913 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:58:30,161 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:31,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:32,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:33,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:33,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:34,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:35,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:36,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:37,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:38,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:39,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:39,453 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:40,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:41,162 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:42,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:43,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:44,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:44,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:44,912 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:58:44,912 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:58:45,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:46,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:47,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:48,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:49,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:50,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:50,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:51,163 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:52,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:53,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:54,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:55,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:55,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:58:56,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:57,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:58,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:59,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:58:59,534 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:58:59,913 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:58:59,913 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:59:00,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:01,039 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:01,164 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:02,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:03,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:04,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:05,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:06,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:06,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:07,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:08,165 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:09,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:10,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:11,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:12,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:12,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:13,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:14,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:14,913 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: stop_status +2024-12-11 00:59:14,913 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: stop_status +2024-12-11 00:59:15,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:16,166 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:17,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:17,454 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:18,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:19,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:20,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:21,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:22,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:23,167 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:23,455 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:24,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:25,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:26,168 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:26,304 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: partial_history +2024-12-11 00:59:26,305 DEBUG SenderThread:843156 [sender.py:send():379] send: history +2024-12-11 00:59:26,306 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: summary_record +2024-12-11 00:59:26,307 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:59:26,307 DEBUG SenderThread:843156 [sender.py:send():379] send: exit +2024-12-11 00:59:26,307 INFO SenderThread:843156 [sender.py:send_exit():586] handling exit code: 1 +2024-12-11 00:59:26,308 INFO SenderThread:843156 [sender.py:send_exit():588] handling runtime: 10917 +2024-12-11 00:59:26,309 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:59:26,309 INFO SenderThread:843156 [sender.py:send_exit():594] send defer +2024-12-11 00:59:26,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:26,309 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 0 +2024-12-11 00:59:26,310 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:26,310 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 0 +2024-12-11 00:59:26,310 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 1 +2024-12-11 00:59:26,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:26,310 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 1 +2024-12-11 00:59:26,310 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:26,310 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 1 +2024-12-11 00:59:26,310 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 2 +2024-12-11 00:59:26,310 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:26,310 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 2 +2024-12-11 00:59:26,310 INFO HandlerThread:843156 [system_monitor.py:finish():203] Stopping system monitor +2024-12-11 00:59:26,310 DEBUG SystemMonitor:843156 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-12-11 00:59:26,311 DEBUG SystemMonitor:843156 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-12-11 00:59:26,312 INFO HandlerThread:843156 [interfaces.py:finish():200] Joined cpu monitor +2024-12-11 00:59:26,313 INFO HandlerThread:843156 [interfaces.py:finish():200] Joined disk monitor +2024-12-11 00:59:26,653 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:59:27,919 INFO HandlerThread:843156 [interfaces.py:finish():200] Joined gpu monitor +2024-12-11 00:59:27,919 INFO HandlerThread:843156 [interfaces.py:finish():200] Joined memory monitor +2024-12-11 00:59:27,920 INFO HandlerThread:843156 [interfaces.py:finish():200] Joined network monitor +2024-12-11 00:59:27,920 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: poll_exit +2024-12-11 00:59:27,920 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,920 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 2 +2024-12-11 00:59:27,920 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 3 +2024-12-11 00:59:27,920 DEBUG SenderThread:843156 [sender.py:send():379] send: stats +2024-12-11 00:59:27,920 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:27,921 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: poll_exit +2024-12-11 00:59:27,921 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 3 +2024-12-11 00:59:27,922 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,922 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 3 +2024-12-11 00:59:27,922 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 4 +2024-12-11 00:59:27,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:27,922 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 4 +2024-12-11 00:59:27,922 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,922 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 4 +2024-12-11 00:59:27,922 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 5 +2024-12-11 00:59:27,922 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:27,922 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 5 +2024-12-11 00:59:27,922 DEBUG SenderThread:843156 [sender.py:send():379] send: summary +2024-12-11 00:59:27,924 INFO SenderThread:843156 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-12-11 00:59:27,924 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,924 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 5 +2024-12-11 00:59:27,924 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 6 +2024-12-11 00:59:27,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:27,924 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 6 +2024-12-11 00:59:27,924 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,924 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 6 +2024-12-11 00:59:27,924 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 7 +2024-12-11 00:59:27,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: status_report +2024-12-11 00:59:27,924 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:27,924 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 7 +2024-12-11 00:59:27,925 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:27,925 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 7 +2024-12-11 00:59:28,307 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: poll_exit +2024-12-11 00:59:28,656 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:59:28,656 INFO Thread-12 :843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:59:30,529 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 8 +2024-12-11 00:59:30,529 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: poll_exit +2024-12-11 00:59:30,529 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:30,529 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 8 +2024-12-11 00:59:30,529 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:30,529 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 8 +2024-12-11 00:59:30,529 INFO SenderThread:843156 [job_builder.py:build():440] Attempting to build job artifact +2024-12-11 00:59:30,530 WARNING SenderThread:843156 [job_builder.py:_log_if_verbose():274] Ensure read and write access to run files dir: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables +2024-12-11 00:59:30,530 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 9 +2024-12-11 00:59:30,530 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:30,530 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 9 +2024-12-11 00:59:30,530 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:30,530 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 9 +2024-12-11 00:59:30,530 INFO SenderThread:843156 [dir_watcher.py:finish():358] shutting down directory watcher +2024-12-11 00:59:30,658 INFO SenderThread:843156 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:59:30,659 INFO SenderThread:843156 [dir_watcher.py:finish():388] scan: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files +2024-12-11 00:59:30,659 INFO SenderThread:843156 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log output.log +2024-12-11 00:59:30,659 INFO SenderThread:843156 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/config.yaml config.yaml +2024-12-11 00:59:30,660 INFO SenderThread:843156 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/requirements.txt requirements.txt +2024-12-11 00:59:30,661 INFO SenderThread:843156 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json wandb-summary.json +2024-12-11 00:59:30,663 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 10 +2024-12-11 00:59:30,665 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:30,666 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 10 +2024-12-11 00:59:30,666 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:30,666 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 10 +2024-12-11 00:59:30,666 INFO SenderThread:843156 [file_pusher.py:finish():169] shutting down file pusher +2024-12-11 00:59:31,099 INFO wandb-upload_0:843156 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/output.log +2024-12-11 00:59:31,258 INFO wandb-upload_2:843156 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/requirements.txt +2024-12-11 00:59:31,259 INFO wandb-upload_3:843156 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/wandb-summary.json +2024-12-11 00:59:31,293 INFO wandb-upload_1:843156 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/files/config.yaml +2024-12-11 00:59:31,309 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: poll_exit +2024-12-11 00:59:31,309 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: poll_exit +2024-12-11 00:59:31,493 INFO Thread-11 (_thread_body):843156 [sender.py:transition_state():614] send defer: 11 +2024-12-11 00:59:31,494 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:31,494 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 11 +2024-12-11 00:59:31,494 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:31,494 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 11 +2024-12-11 00:59:31,494 INFO SenderThread:843156 [file_pusher.py:join():175] waiting for file pusher +2024-12-11 00:59:31,495 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 12 +2024-12-11 00:59:31,495 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:31,495 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 12 +2024-12-11 00:59:31,495 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:31,495 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 12 +2024-12-11 00:59:31,495 INFO SenderThread:843156 [file_stream.py:finish():601] file stream finish called +2024-12-11 00:59:31,567 INFO SenderThread:843156 [file_stream.py:finish():605] file stream finish is done +2024-12-11 00:59:31,567 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 13 +2024-12-11 00:59:31,567 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:31,567 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 13 +2024-12-11 00:59:31,567 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:31,567 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 13 +2024-12-11 00:59:31,567 INFO SenderThread:843156 [sender.py:transition_state():614] send defer: 14 +2024-12-11 00:59:31,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: defer +2024-12-11 00:59:31,568 DEBUG SenderThread:843156 [sender.py:send():379] send: final +2024-12-11 00:59:31,568 INFO HandlerThread:843156 [handler.py:handle_request_defer():184] handle defer: 14 +2024-12-11 00:59:31,568 DEBUG SenderThread:843156 [sender.py:send():379] send: footer +2024-12-11 00:59:31,568 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: defer +2024-12-11 00:59:31,568 INFO SenderThread:843156 [sender.py:send_request_defer():610] handle sender defer: 14 +2024-12-11 00:59:31,568 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: poll_exit +2024-12-11 00:59:31,568 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: poll_exit +2024-12-11 00:59:31,569 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: server_info +2024-12-11 00:59:31,569 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: server_info +2024-12-11 00:59:31,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: poll_exit +2024-12-11 00:59:31,570 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: get_summary +2024-12-11 00:59:31,571 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: sampled_history +2024-12-11 00:59:31,572 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: internal_messages +2024-12-11 00:59:31,638 DEBUG SenderThread:843156 [sender.py:send_request():406] send_request: poll_exit +2024-12-11 00:59:31,638 INFO MainThread:843156 [wandb_run.py:_footer_history_summary_info():4008] rendering history +2024-12-11 00:59:31,639 INFO MainThread:843156 [wandb_run.py:_footer_history_summary_info():4040] rendering summary +2024-12-11 00:59:31,639 INFO MainThread:843156 [wandb_run.py:_footer_sync_info():3967] logging synced files +2024-12-11 00:59:31,640 DEBUG HandlerThread:843156 [handler.py:handle_request():158] handle_request: shutdown +2024-12-11 00:59:31,640 INFO HandlerThread:843156 [handler.py:finish():882] shutting down handler +2024-12-11 00:59:32,570 INFO WriterThread:843156 [datastore.py:close():296] close: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/run-bold5k_nsdm1.wandb +2024-12-11 00:59:32,638 INFO SenderThread:843156 [sender.py:finish():1608] shutting down sender +2024-12-11 00:59:32,638 INFO SenderThread:843156 [file_pusher.py:finish():169] shutting down file pusher +2024-12-11 00:59:32,638 INFO SenderThread:843156 [file_pusher.py:join():175] waiting for file pusher diff --git a/MindEyeV2/src/wandb/debug.log b/MindEyeV2/src/wandb/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..893c228816d96285ab7cfda9766893a3ee6955e5 --- /dev/null +++ b/MindEyeV2/src/wandb/debug.log @@ -0,0 +1,30 @@ +2024-12-10 21:57:28,176 INFO MainThread:842903 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Configure stats pid to 842903 +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False} +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': 'src/TrainB5k.py', 'program_abspath': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainB5k.py', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainB5k.py'} +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/logs/debug.log +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215728-bold5k_nsdm1/logs/debug-internal.log +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:init():560] calling init triggers +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'bold5k_nsdm1', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 150, 'num_sessions': 15, 'num_params': 2239051016, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 4323, 'num_test': 480, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1} +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:init():610] starting backend +2024-12-10 21:57:28,177 INFO MainThread:842903 [wandb_init.py:init():614] setting up manager +2024-12-10 21:57:28,179 INFO MainThread:842903 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-12-10 21:57:28,182 INFO MainThread:842903 [wandb_init.py:init():622] backend started and connected +2024-12-10 21:57:28,187 INFO MainThread:842903 [wandb_init.py:init():711] updated telemetry +2024-12-10 21:57:28,198 INFO MainThread:842903 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-12-10 21:57:28,693 INFO MainThread:842903 [wandb_init.py:init():787] run resumed +2024-12-10 21:57:28,707 INFO MainThread:842903 [wandb_run.py:_on_init():2402] communicating current version +2024-12-10 21:57:28,770 INFO MainThread:842903 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.19.0 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-12-10 21:57:28,770 INFO MainThread:842903 [wandb_init.py:init():795] starting run threads in backend +2024-12-10 21:57:29,319 INFO MainThread:842903 [wandb_run.py:_console_start():2380] atexit reg +2024-12-10 21:57:29,319 INFO MainThread:842903 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-12-10 21:57:29,319 INFO MainThread:842903 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-12-10 21:57:29,319 INFO MainThread:842903 [wandb_run.py:_redirect():2325] Redirects installed. +2024-12-10 21:57:29,322 INFO MainThread:842903 [wandb_init.py:init():838] run started, returning control to user process +2024-12-11 00:59:32,641 WARNING MsgRouterThr:842903 [router.py:message_loop():77] message_loop has been closed diff --git a/MindEyeV2/src/wandb/run-20240618_035407-rr-test/files/config.yaml b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ceb5125920264d3e11da0d914c5965c12a74fa7e --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/files/config.yaml @@ -0,0 +1,102 @@ +wandb_version: 1 + +model_name: + desc: null + value: rr-test +global_batch_size: + desc: null + value: '21' +batch_size: + desc: null + value: 3 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 40 +num_params: + desc: null + value: 573919937 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 0.0003 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 3750 +num_test: + desc: null + value: 3000 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: true +seed: + desc: null + value: 42 +distributed: + desc: null + value: true +num_devices: + desc: null + value: 8 +world_size: + desc: null + value: 1 +train_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar +test_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar +_wandb: + desc: null + value: + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1718682847 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 13 + - 14 + - 16 + - 23 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug-internal.log b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..863e8892767a61f85769498b52efd8f5a9f9bb24 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug-internal.log @@ -0,0 +1,61 @@ +2024-06-18 03:54:07,351 INFO StreamThr :2245613 [internal.py:wandb_internal():85] W&B internal server running at pid: 2245613, started at: 2024-06-18 03:54:07.345742 +2024-06-18 03:54:07,352 DEBUG HandlerThread:2245613 [handler.py:handle_request():158] handle_request: status +2024-06-18 03:54:07,375 INFO WriterThread:2245613 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_035407-rr-test/run-rr-test.wandb +2024-06-18 03:54:07,379 DEBUG SenderThread:2245613 [sender.py:send():379] send: header +2024-06-18 03:54:07,462 DEBUG SenderThread:2245613 [sender.py:send():379] send: run +2024-06-18 03:54:07,474 INFO SenderThread:2245613 [sender.py:_setup_resume():749] checking resume status for None/mindeye_semantic_cluster/rr-test +2024-06-18 03:54:07,670 ERROR SenderThread:2245613 [internal_api.py:execute():344] 401 response executing GraphQL. +2024-06-18 03:54:07,670 ERROR SenderThread:2245613 [internal_api.py:execute():345] {"errors":[{"message":"user is not logged in","path":["upsertBucket"],"extensions":{"code":"PERMISSION_ERROR"}}],"data":{"upsertBucket":null}} +2024-06-18 03:54:07,670 ERROR SenderThread:2245613 [sender.py:send_run():1009] The API key you provided is either invalid or missing. If the `WANDB_API_KEY` environment variable is set, make sure it is correct. Otherwise, to resolve this issue, you may try running the 'wandb login --relogin' command. If you are using a local server, make sure that you're using the correct hostname. If you're not sure, you can try logging in again using the 'wandb login --relogin --host [hostname]' command.(Error 401: Unauthorized) +Traceback (most recent call last): + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/lib/retry.py", line 131, in __call__ + result = self._call_fn(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/internal/internal_api.py", line 340, in execute + return self.client.execute(*args, **kwargs) # type: ignore + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/vendor/gql-0.2.0/wandb_gql/client.py", line 52, in execute + result = self._get_result(document, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/vendor/gql-0.2.0/wandb_gql/client.py", line 60, in _get_result + return self.transport.execute(document, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/lib/gql_request.py", line 59, in execute + request.raise_for_status() + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/requests/models.py", line 1024, in raise_for_status + raise HTTPError(http_error_msg, response=self) +requests.exceptions.HTTPError: 401 Client Error: Unauthorized for url: https://api.wandb.ai/graphql + +During handling of the above exception, another exception occurred: + +Traceback (most recent call last): + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/internal/sender.py", line 1007, in send_run + server_run = self._init_run(run, config_value_dict) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/internal/sender.py", line 1079, in _init_run + server_run, inserted, server_messages = self._api.upsert_run( + ^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/apis/normalize.py", line 73, in wrapper + raise err + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/apis/normalize.py", line 41, in wrapper + return func(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/internal/internal_api.py", line 2188, in upsert_run + response = self.gql( + ^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/internal/internal_api.py", line 312, in gql + ret = self._retry_gql( + ^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/lib/retry.py", line 147, in __call__ + retry_timedelta_triggered = check_retry_fn(e) + ^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/util.py", line 965, in check_retry_fn + return fallback_retry_fn(e) + ^^^^^^^^^^^^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/util.py", line 896, in no_retry_auth + raise AuthenticationError( +wandb.errors.AuthenticationError: The API key you provided is either invalid or missing. If the `WANDB_API_KEY` environment variable is set, make sure it is correct. Otherwise, to resolve this issue, you may try running the 'wandb login --relogin' command. If you are using a local server, make sure that you're using the correct hostname. If you're not sure, you can try logging in again using the 'wandb login --relogin --host [hostname]' command.(Error 401: Unauthorized) +2024-06-18 03:54:07,847 DEBUG HandlerThread:2245613 [handler.py:handle_request():158] handle_request: shutdown +2024-06-18 03:54:07,847 INFO HandlerThread:2245613 [handler.py:finish():882] shutting down handler +2024-06-18 03:54:08,462 INFO WriterThread:2245613 [datastore.py:close():296] close: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_035407-rr-test/run-rr-test.wandb +2024-06-18 03:54:08,695 INFO SenderThread:2245613 [sender.py:finish():1608] shutting down sender diff --git a/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug.log b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..bc3e948ccbc815062f9cd05c87213559ffd5a716 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug.log @@ -0,0 +1,29 @@ +2024-06-18 03:54:07,333 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Configure stats pid to 2245259 +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False} +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': 'src/TrainCluster.py', 'program_abspath': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py'} +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-06-18 03:54:07,334 INFO MainThread:2245259 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug.log +2024-06-18 03:54:07,335 INFO MainThread:2245259 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_035407-rr-test/logs/debug-internal.log +2024-06-18 03:54:07,335 INFO MainThread:2245259 [wandb_init.py:init():560] calling init triggers +2024-06-18 03:54:07,335 INFO MainThread:2245259 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'rr-test', 'global_batch_size': '21', 'batch_size': 3, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 573919937, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 3750, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': True, 'num_devices': 8, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar'} +2024-06-18 03:54:07,335 INFO MainThread:2245259 [wandb_init.py:init():610] starting backend +2024-06-18 03:54:07,335 INFO MainThread:2245259 [wandb_init.py:init():614] setting up manager +2024-06-18 03:54:07,344 INFO MainThread:2245259 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-06-18 03:54:07,352 INFO MainThread:2245259 [wandb_init.py:init():622] backend started and connected +2024-06-18 03:54:07,374 INFO MainThread:2245259 [wandb_init.py:init():711] updated telemetry +2024-06-18 03:54:07,461 INFO MainThread:2245259 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-06-18 03:54:07,695 ERROR MainThread:2245259 [wandb_init.py:init():770] encountered error: The API key you provided is either invalid or missing. If the `WANDB_API_KEY` environment variable is set, make sure it is correct. Otherwise, to resolve this issue, you may try running the 'wandb login --relogin' command. If you are using a local server, make sure that you're using the correct hostname. If you're not sure, you can try logging in again using the 'wandb login --relogin --host [hostname]' command.(Error 401: Unauthorized) +2024-06-18 03:54:07,695 ERROR MainThread:2245259 [wandb_init.py:init():1181] error in wandb.init() +Traceback (most recent call last): + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/wandb_init.py", line 1171, in init + return wi.init() + ^^^^^^^^^ + File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/wandb/sdk/wandb_init.py", line 776, in init + raise error +wandb.errors.AuthenticationError: The API key you provided is either invalid or missing. If the `WANDB_API_KEY` environment variable is set, make sure it is correct. Otherwise, to resolve this issue, you may try running the 'wandb login --relogin' command. If you are using a local server, make sure that you're using the correct hostname. If you're not sure, you can try logging in again using the 'wandb login --relogin --host [hostname]' command.(Error 401: Unauthorized) +2024-06-18 03:54:08,847 WARNING MsgRouterThr:2245259 [router.py:message_loop():77] message_loop has been closed diff --git a/MindEyeV2/src/wandb/run-20240618_035407-rr-test/run-rr-test.wandb b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/run-rr-test.wandb new file mode 100644 index 0000000000000000000000000000000000000000..40638dc0cd7bcc6e8ca6511eda4dced2c267396b Binary files /dev/null and b/MindEyeV2/src/wandb/run-20240618_035407-rr-test/run-rr-test.wandb differ diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code/src/TrainCluster.py b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code/src/TrainCluster.py new file mode 100644 index 0000000000000000000000000000000000000000..53d2eb98d5d6f4ea37db4dc355b6ae31c2ab6f27 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code/src/TrainCluster.py @@ -0,0 +1,1069 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Import packages & functions + +# In[1]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm +import webdataset as wds + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from accelerate import Accelerator + +# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main +sys.path.append('generative_models/') +import sgm +from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[2]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +data_type = torch.float16 # change depending on your mixed_precision +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# First use "accelerate config" in terminal and setup using deepspeed stage 2 with CPU offloading! +accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job + global_batch_size = batch_size = 8 +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + + +# In[3]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +num_devices = torch.cuda.device_count() +if num_devices==0 or not distributed: num_devices = 1 +num_workers = num_devices +print(accelerator.state) + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[4]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + model_name = "testing" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the 2nd cell block + jupyter_args = f"--data_path=/weka/proj-medarc/shared/mindeyev2_dataset \ + --cache_dir=/weka/proj-medarc/shared/cache \ + --model_name={model_name} \ + --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=40 \ + --hidden_dim=1024 --clip_scale=1. \ + --no-blurry_recon --blur_scale=.5 \ + --use_prior --prior_scale=30 \ + --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \ + --ckpt_interval=999 --no-ckpt_saving --no-wandb_log" + # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow + + print(jupyter_args) + jupyter_args = jupyter_args.split() + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[5]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default=os.getcwd(), + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--cache_dir", type=str, default=os.getcwd(), + help="Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8], + help="Validate on which subject?", +) +parser.add_argument( + "--multisubject_ckpt", type=str, default=None, + help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.", +) +parser.add_argument( + "--num_sessions", type=int, default=1, + help="Number of training sessions to include", +) +parser.add_argument( + "--use_prior",action=argparse.BooleanOptionalAction,default=True, + help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)", +) +parser.add_argument( + "--batch_size", type=int, default=16, + help="Batch size can be increased by 10x if only training retreival submodule and not diffusion prior", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=.5, + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--prior_scale",type=float,default=30, + help="multiply diffusion prior loss by this", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=False, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=150, + help="number of epochs of training", +) +parser.add_argument( + "--multi_subject",action=argparse.BooleanOptionalAction,default=False, +) +parser.add_argument( + "--new_test",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--n_blocks",type=int,default=4, +) +parser.add_argument( + "--hidden_dim",type=int,default=1024, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +# seed all random functions +utils.seed_everything(seed) + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) + +if use_image_aug or blurry_recon: + import kornia + from kornia.augmentation.container import AugmentationSequential +if use_image_aug: + img_augment = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + +if multi_subject: + subj_list = np.arange(1,9) + subj_list = subj_list[subj_list != subj] +else: + subj_list = [subj] + +print("subj_list", subj_list, "num_sessions", num_sessions) + + +# # Prep data, models, and dataloaders + +# ### Creating wds dataloader, preload betas and all 73k possible images + +# In[6]: + + +def my_split_by_node(urls): return urls +num_voxels_list = [] + +if multi_subject: + nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30]) + num_samples_per_epoch = (750*40) // num_devices +else: + num_samples_per_epoch = (750*num_sessions) // num_devices + +print("dividing batch size by subj_list, which will then be concatenated across subj during training...") +batch_size = batch_size // len(subj_list) + +num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list)) + +print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch) + + +# In[7]: + + +train_data = {} +train_dl = {} +num_voxels = {} +voxels = {} +for s in subj_list: + print(f"Training with {num_sessions} sessions") + if multi_subject: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{nsessions_allsubj[s-1]-1}" + "}.tar" + else: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{num_sessions-1}" + "}.tar" + print(train_url) + + train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) + train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + + f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r') + betas = f['betas'][:] + betas = torch.Tensor(betas).to("cpu").to(data_type) + num_voxels_list.append(betas[0].shape[-1]) + num_voxels[f'subj0{s}'] = betas[0].shape[-1] + voxels[f'subj0{s}'] = betas + print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}") + +print("Loaded all subj train dls and betas!\n") + +# Validate only on one subject +if multi_subject: + subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list +if not new_test: # using old test set from before full dataset released (used in original MindEye paper) + if subj==3: + num_test=2113 + elif subj==4: + num_test=1985 + elif subj==6: + num_test=2113 + elif subj==8: + num_test=1985 + else: + num_test=2770 + test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +elif new_test: # using larger test set from after full dataset released + if subj==3: + num_test=2371 + elif subj==4: + num_test=2188 + elif subj==6: + num_test=2371 + elif subj==8: + num_test=2188 + else: + num_test=3000 + test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" +print(test_url) +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +print(f"Loaded test dl for subj{subj}!\n") + + +# In[8]: + + +# Load 73k NSD images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'] +print("Loaded all 73k possible NSD images to cpu!", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[9]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) + +clip_seq_dim = 256 +clip_emb_dim = 1664 + + +# ### SD VAE + +# In[10]: + + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + from autoencoder.convnext import ConvnextXL + cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth') + cnx.requires_grad_(False) + cnx.eval() + cnx.to(device) + + mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1) + std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1) + + blur_augs = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8), + kornia.augmentation.RandomGrayscale(p=0.1), + kornia.augmentation.RandomSolarize(p=0.1), + kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0), + data_keys=["input"], + ) + + +# ### MindEye modules + +# In[11]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[12]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +class IndividRidgeRegression(torch.nn.Module): + def __init__(self, input_size, out_features): + super(IndividRidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + out = self.linear(x) + return out + +model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +# test on subject 1 with fake data +b = torch.randn((2,1,num_voxels_list[0])) +print(b.shape, model.ridge(b,0).shape) + + +# In[13]: + + +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, + blurry_recon=blurry_recon, clip_scale=clip_scale) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((2,1,hidden_dim)) +print("b.shape",b.shape) + +backbone_, clip_, blur_ = model.backbone(b) +print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape) + + +# ### Load semantic clusters + +# In[14]: + + +path_semantic_names = "/weka/proj-medarc/shared/mindeyev2_dataset/semantic_cluster_names.npy" +path_semantic_cluster = "/weka/proj-medarc/shared/mindeyev2_dataset/COCO_73k_semantic_cluster.npy" +semantic_cluster_names = np.load(path_semantic_names) +semantic_cluster = np.load(path_semantic_cluster) +possible_semantic_clusters = np.unique(semantic_cluster) + +# one-hot encode semantic clusters +# move possible_semantic_clusters to numbers and create a dictionary +semantic_cluster_dict = {cluster: i for i, cluster in enumerate(possible_semantic_clusters)} +semantic_cluster_onehot = torch.zeros((len(semantic_cluster), len(possible_semantic_clusters))) +for i, cluster in enumerate(semantic_cluster): + semantic_cluster_onehot[i, semantic_cluster_dict[cluster]] = 1 + + +print("semantic_cluster_onehot.shape", semantic_cluster_onehot.shape) + +num_seman_clusters = len(np.unique(semantic_cluster)) +print("num_seman_clusters", num_seman_clusters) + + +# ### Adding the ridge regression to the class + +# In[15]: + + +# if use_prior: +# from models import * + +# # setup diffusion prior network +# out_dim = clip_emb_dim +# depth = 6 +# dim_head = 52 +# heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim +# timesteps = 100 + +# prior_network = PriorNetwork( +# dim=out_dim, +# depth=depth, +# dim_head=dim_head, +# heads=heads, +# causal=False, +# num_tokens = clip_seq_dim, +# learned_query_mode="pos_emb" +# ) + +# model.diffusion_prior = BrainDiffusionPrior( +# net=prior_network, +# image_embed_dim=out_dim, +# condition_on_text_encodings=False, +# timesteps=timesteps, +# cond_drop_prob=0.2, +# image_embed_scale=None, +# ) + +# utils.count_params(model.diffusion_prior) +# utils.count_params(model) + +model.RRClassifier = IndividRidgeRegression(clip_emb_dim*clip_seq_dim, out_features=num_seman_clusters) +utils.count_params(model.RRClassifier) +utils.count_params(model) + + +# ### Setup optimizer / lr / ckpt saving + +# In[16]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] + +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] +# if use_prior: +# opt_grouped_parameters.extend([ +# {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, +# {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} +# ]) +opt_grouped_parameters.extend([ + {'params': [p for n, p in model.RRClassifier.named_parameters()], 'weight_decay': 1e-2}, +]) + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*num_iterations_per_epoch)) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + if accelerator.is_main_process: + unwrapped_model = accelerator.unwrap_model(model) + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + print(f"\n---saved {outdir}/{tag} ckpt!---\n") + +def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): + print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + if multisubj_loading: # remove incompatible ridge layer that will otherwise error + state_dict.pop('ridge.linears.0.weight',None) + model.load_state_dict(state_dict, strict=strict) + if load_epoch: + globals()["epoch"] = checkpoint['epoch'] + print("Epoch",epoch) + if load_optimizer: + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + if load_lr: + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + del checkpoint + +print("\nDone with model preparations!") +num_params = utils.count_params(model) + + +# # Weights and Biases + +# In[17]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeye_semantic_cluster' + print(f"wandb {wandb_project} run {model_name}") + # need to configure wandb beforehand in terminal with "wandb init"! + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "num_sessions": num_sessions, + "num_params": num_params, + "clip_scale": clip_scale, + "prior_scale": prior_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_samples_per_epoch": num_samples_per_epoch, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + print("wandb_id:",model_name) + wandb.init( + id=model_name, + project=wandb_project, + name=model_name, + config=wandb_config, + resume="allow", + ) +else: + wandb_log = False + + +# # Main + +# In[18]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +torch.cuda.empty_cache() + + +# In[19]: + + +# load multisubject stage1 ckpt if set +if multisubject_ckpt is not None: + load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True) + + +# In[20]: + + +train_dls = [train_dl[f'subj0{s}'] for s in subj_list] + +model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot = accelerator.prepare(model, optimizer, *train_dls, lr_scheduler, semantic_cluster_onehot) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[21]: + + +print(num_iterations_per_epoch) + + +# In[26]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + recon_cossim = 0. + test_recon_cossim = 0. + recon_mse = 0. + test_recon_mse = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_blurry_cont_total = 0. + test_loss_clip_total = 0. + + loss_prior_total = 0. + test_loss_prior_total = 0. + + loss_RR_total = 0. + test_loss_RR_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch) + voxel_iters = {} # empty dict because diff subjects have differing # of voxels + image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float() + annot_iters = {} + perm_iters, betas_iters, select_iters = {}, {}, {} + images_indexes = {} + for s, train_dl in enumerate(train_dls): + with torch.cuda.amp.autocast(dtype=data_type): + iter = -1 + for behav0, past_behav0, future_behav0, old_behav0 in train_dl: + # Load images to cpu from hdf5 (requires sorted indexing) + image_idx = behav0[:,0,0].cpu().long().numpy() + + image0, image_sorted_idx = np.unique(image_idx, return_index=True) + if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing + continue + iter += 1 + image0 = torch.tensor(images[image0], dtype=data_type) + image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0 + images_indexes[f"subj0{s}_iter{iter}"] = image_sorted_idx + + # Load voxels for current batch, matching above indexing + voxel_idx = behav0[:,0,5].cpu().long().numpy() + voxel_sorted_idx = voxel_idx[image_sorted_idx] + voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx] + voxel0 = torch.Tensor(voxel0).unsqueeze(1) + + if epoch < int(mixup_pct * num_epochs): + voxel0, perm, betas, select = utils.mixco(voxel0) + perm_iters[f"subj0{subj_list[s]}_iter{iter}"] = perm + betas_iters[f"subj0{subj_list[s]}_iter{iter}"] = betas + select_iters[f"subj0{subj_list[s]}_iter{iter}"] = select + + voxel_iters[f"subj0{subj_list[s]}_iter{iter}"] = voxel0 + + if iter >= num_iterations_per_epoch-1: + break + + # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each + for train_i in range(num_iterations_per_epoch): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + loss=0. + + voxel_list = [voxel_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + image = image_iters[train_i].detach() + image = image.to(device) + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_img_embedder(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + perm_list = [perm_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + perm = torch.cat(perm_list, dim=0) + betas_list = [betas_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + betas = torch.cat(betas_list, dim=0) + select_list = [select_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + select = torch.cat(select_list, dim=0) + + voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)] + voxel_ridge = torch.cat(voxel_ridge_list, dim=0) + + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # if use_prior: + # loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target) + # loss_prior_total += loss_prior.item() + # loss_prior *= prior_scale + # loss += loss_prior + + # recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item() + # recon_mse += mse(prior_out, clip_target).item() + + logits = model.RRClassifier(backbone.flatten(1)) + loss_RR = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[images_indexes[f"subj0{s}_iter{train_i}"]], dim=1).to(logits.device)) + #print("backbone.shape",backbone.shape, "clip_voxels.shape",clip_voxels.shape, "blurry_image_enc_[0].shape",blurry_image_enc_[0].shape, "blurry_image_enc_[1].shape",blurry_image_enc_[1].shape) + #something + + loss_RR_total += loss_RR.item() + loss += loss_RR + + if clip_scale>0: + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, transformer_feats = blurry_image_enc_ + + image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215 + loss_blurry = l1(image_enc_pred, image_enc) + loss_blurry_total += loss_blurry.item() + + if epoch < int(mixup_pct * num_epochs): + image_enc_shuf = image_enc[perm] + betas_shape = [-1] + [1]*(len(image_enc.shape)-1) + image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \ + image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape) + + image_norm = (image - mean)/std + image_aug = (blur_augs(image) - mean)/std + _, cnx_embeds = cnx(image_norm) + _, cnx_aug_embeds = cnx(image_aug) + + cont_loss = utils.soft_cont_loss( + nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1), + nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + temp=0.2) + loss_blurry_cont_total += cont_loss.item() + + loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215 + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + blurry_pixcorr += pixcorr.item() + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if len(locs)==1: + locs = locs.repeat(3) + elif len(locs)==2: + locs = locs.repeat(2)[:3] + assert len(locs)==3 + if test_image is None: + test_image = torch.Tensor(images[im][None]) + test_voxel = voxel[locs][None] + else: + test_image = torch.vstack((test_image, torch.Tensor(images[im][None]))) + test_voxel = torch.vstack((test_voxel, voxel[locs][None])) + + loss=0. + + test_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[test_indices].to(device) + image = test_image[test_indices].to(device) + assert len(image) == 300 + + clip_target = clip_img_embedder(image.float()) + + for rep in range(3): + voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list + backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge) + + logits0 = model.RRClassifier(backbone0.flatten(1)) + + if rep==0: + clip_voxels = clip_voxels0 + backbone = backbone0 + logits = logits0 + else: + clip_voxels += clip_voxels0 + backbone += backbone0 + logits += logits0 + clip_voxels /= 3 + backbone /= 3 + logits /= 3 + + print(logits.shape, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).shape) + RR_loss = nn.functional.cross_entropy(logits, torch.argmax(semantic_cluster_onehot[test_indices], dim=1).to(logits.device)) + test_loss_RR_total += RR_loss.item() + loss += RR_loss + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # for some evals, only doing a subset of the samples per batch because of computational cost + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + + # if use_prior: + # loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps]) + # test_loss_prior_total += loss_prior.item() + # loss_prior *= prior_scale + # loss += loss_prior + + if clip_scale>0: + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, _ = blurry_image_enc_ + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + test_blurry_pixcorr += pixcorr.item() + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/recon_cossim": recon_cossim / (train_i + 1), + "test/recon_cossim": test_recon_cossim / (test_i + 1), + "train/recon_mse": recon_mse / (train_i + 1), + "test/recon_mse": test_recon_mse / (test_i + 1), + "train/loss_prior": loss_prior_total / (train_i + 1), + "test/loss_prior": test_loss_prior_total / (test_i + 1), + "train/loss_RR": loss_RR_total / (train_i + 1), + "test/loss_RR": test_loss_RR_total / (test_i + 1), + } + + # if finished training, save jpg recons if they exist + if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0): + if blurry_recon: + image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215 + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/blur_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + if wandb_log: wandb.log(logs) + + # Save model checkpoint and reconstruct + if (ckpt_saving) and (epoch % ckpt_interval == 0): + save_ckpt(f'last') + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# In[29]: + + +import wandb +wandb.login() + diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/config.yaml b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ae6dd815ca57dc70170d22448dc08d227459639 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/config.yaml @@ -0,0 +1,103 @@ +wandb_version: 1 + +model_name: + desc: null + value: rr-test +global_batch_size: + desc: null + value: '21' +batch_size: + desc: null + value: 3 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 40 +num_params: + desc: null + value: 573919937 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 0.0003 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 3750 +num_test: + desc: null + value: 3000 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: true +seed: + desc: null + value: 42 +distributed: + desc: null + value: true +num_devices: + desc: null + value: 8 +world_size: + desc: null + value: 1 +train_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar +test_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar +_wandb: + desc: null + value: + code_path: code/src/TrainCluster.py + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1718712973 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 13 + - 14 + - 16 + - 23 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/diff.patch b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/diff.patch new file mode 100644 index 0000000000000000000000000000000000000000..1efc4740c4fb320586c49d3224dee88dab9c8171 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/diff.patch @@ -0,0 +1,230 @@ +diff --git a/src/Train.ipynb b/src/Train.ipynb +index 91922c8..396549d 100644 +--- a/src/Train.ipynb ++++ b/src/Train.ipynb +@@ -99,7 +99,7 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "PID of this process = 3001293\n", ++ "PID of this process = 3520819\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", +@@ -1362,9 +1362,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { +diff --git a/src/accel.slurm b/src/accel.slurm +index 1c1dfbc..5623c78 100644 +--- a/src/accel.slurm ++++ b/src/accel.slurm +@@ -1,7 +1,7 @@ + #!/bin/bash +-#SBATCH --account=topfmri +-#SBATCH --partition=a40x +-#SBATCH --job-name=eye ++#SBATCH --account=fmri ++#SBATCH --partition=p5 ++#SBATCH --job-name=eyeRR + #SBATCH --nodes=1 + #SBATCH --gres=gpu:1 + #SBATCH --time=48:00:00 # total run time limit (HH:MM:SS) +@@ -12,11 +12,11 @@ + #SBATCH --exclusive + + # Make sure you activate your fmri environment created from src/setup.sh +-cd /weka/proj-fmri/paulscotti/MindEyeV2/src +-source fmri/bin/activate ++cd /weka/proj-fmri/ckadirt/MindEyeV2/src ++source /admin/home-ckadirt/fmri/bin/activate + + # The following line converts your jupyter notebook into a python script runnable with Slurm +-jupyter nbconvert Train.ipynb --to python ++jupyter nbconvert TrainCluster.ipynb --to python + + export NUM_GPUS=1 # Set to equal gres=gpu:#! + export BATCH_SIZE=21 # 21 for multisubject / 24 for singlesubject (orig. paper used 42 for multisubject / 24 for singlesubject) +@@ -32,9 +32,9 @@ echo MASTER_PORT=${MASTER_PORT} + echo WORLD_SIZE=${COUNT_NODE} + + # multisubject pretraining +-model_name="multisubject_excludingsubj01_40sess" ++model_name="rr-test" + echo model_name=${model_name} +-accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log ++accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log + + # singlesubject finetuning + #model_name="finetuned_subj01_40sess" +diff --git a/src/recon_inference.ipynb b/src/recon_inference.ipynb +index 10d7e27..0593e7e 100644 +--- a/src/recon_inference.ipynb ++++ b/src/recon_inference.ipynb +@@ -12,7 +12,6 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "LOCAL RANK 0\n", + "device: cuda\n" + ] + } +@@ -60,7 +59,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 33, ++ "execution_count": 2, + "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8", + "metadata": { + "tags": [] +@@ -71,9 +70,7 @@ + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_40sess_24bs\n", +- "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n", +- "The autoreload extension is already loaded. To reload it, use:\n", +- " %reload_ext autoreload\n" ++ "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n" + ] + } + ], +@@ -99,7 +96,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 34, ++ "execution_count": 3, + "id": "49e5dae4-606d-4dc6-b420-df9e4c14737e", + "metadata": { + "tags": [] +@@ -157,7 +154,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 35, ++ "execution_count": 4, + "id": "64672583-9f00-46f5-8d4e-00e4c7068a1d", + "metadata": { + "tags": [] +@@ -221,7 +218,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 36, ++ "execution_count": 5, + "id": "a3cbeea8-e95b-48d9-9bc2-91af260c93d1", + "metadata": {}, + "outputs": [ +@@ -254,39 +251,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 38, ++ "execution_count": null, + "id": "3afc4858-b6a6-4a52-9303-b4a50ea5cc0b", + "metadata": {}, +- "outputs": [ +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "param counts:\n", +- "83,653,863 total\n", +- "0 trainable\n", +- "param counts:\n", +- "64,409,600 total\n", +- "64,409,600 trainable\n", +- "param counts:\n", +- "1,903,020,028 total\n", +- "1,903,020,028 trainable\n", +- "param counts:\n", +- "1,967,429,628 total\n", +- "1,967,429,628 trainable\n", +- "param counts:\n", +- "259,865,216 total\n", +- "259,865,200 trainable\n", +- "param counts:\n", +- "2,227,294,844 total\n", +- "2,227,294,828 trainable\n", +- "\n", +- "---loading /weka/proj-fmri/paulscotti/MindEye2_git/train_logs/final_subj01_pretrained_40sess_24bs/last.pth ckpt---\n", +- "\n", +- "ckpt loaded!\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", +@@ -393,7 +361,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 30, ++ "execution_count": null, + "id": "295824db-ab3d-450c-90fb-f656e48994ba", + "metadata": { + "tags": [] +@@ -430,38 +398,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 31, ++ "execution_count": null, + "id": "f726f617-39f5-49e2-8d0c-d11d27d01c30", + "metadata": {}, +- "outputs": [ +- { +- "name": "stderr", +- "output_type": "stream", +- "text": [ +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n" +- ] +- }, +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False\n", +- "Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "vector_suffix torch.Size([1, 1024])\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "# prep unCLIP\n", + "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n", +@@ -715,9 +655,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/requirements.txt b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..50e0d3d69897318dd1392b05951c7b32a37ce997 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/requirements.txt @@ -0,0 +1,214 @@ +Babel==2.15.0 +CoCa-pytorch==0.1.0 +GitPython==3.1.43 +Jinja2==3.1.4 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Pygments==2.18.0 +QtPy==2.4.1 +Send2Trash==1.8.3 +absl-py==2.1.0 +accelerate==0.24.1 +aiohttp==3.9.5 +aiosignal==1.3.1 +annotated-types==0.7.0 +antlr4-python3-runtime==4.9.3 +anyio==4.4.0 +argon2-cffi-bindings==21.2.0 +argon2-cffi==23.1.0 +arrow==1.3.0 +asttokens==2.4.1 +async-lru==2.0.4 +attrs==23.2.0 +beartype==0.18.5 +beautifulsoup4==4.12.3 +bleach==6.1.0 +braceexpand==0.1.7 +certifi==2024.6.2 +cffi==1.16.0 +charset-normalizer==3.3.2 +click==8.1.7 +clip-anytorch==2.6.0 +clip==1.0 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +dalle2-pytorch==1.15.6 +datasets==2.20.0 +debugpy==1.8.1 +decorator==5.1.1 +deepspeed==0.13.1 +defusedxml==0.7.1 +diffusers==0.23.0 +dill==0.3.8 +docker-pycreds==0.4.0 +einops==0.8.0 +einx==0.3.0 +ema-pytorch==0.5.0 +embedding-reader==1.7.0 +evaluate==0.4.1 +executing==2.0.1 +fastjsonschema==2.20.0 +filelock==3.15.1 +fonttools==4.53.0 +fqdn==1.5.1 +frozendict==2.4.4 +frozenlist==1.4.1 +fsspec==2024.5.0 +ftfy==6.2.0 +gitdb==4.0.11 +h11==0.14.0 +h5py==3.10.0 +hjson==3.1.0 +httpcore==1.0.5 +httpx==0.27.0 +huggingface-hub==0.23.4 +idna==3.7 +imageio==2.34.1 +importlib_metadata==7.1.0 +ipykernel==6.29.4 +ipython==8.25.0 +ipywidgets==8.1.3 +isoduration==20.11.0 +jedi==0.19.1 +joblib==1.4.2 +json5==0.9.25 +jsonpointer==3.0.0 +jsonschema-specifications==2023.12.1 +jsonschema==4.22.0 +jupyter-console==6.6.3 +jupyter-events==0.10.0 +jupyter-lsp==2.2.5 +jupyter==1.0.0 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +jupyter_server==2.14.1 +jupyter_server_terminals==0.5.3 +jupyterlab==4.2.2 +jupyterlab_nvdashboard==0.11.0 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.27.2 +jupyterlab_widgets==3.0.11 +kiwisolver==1.4.5 +kornia==0.7.1 +lazy_loader==0.4 +lightning-utilities==0.11.2 +matplotlib-inline==0.1.7 +matplotlib==3.8.2 +mistune==3.0.2 +mpmath==1.3.0 +multidict==6.0.5 +multiprocess==0.70.16 +nbclient==0.10.0 +nbconvert==7.16.4 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.3 +ninja==1.11.1.1 +nltk==3.8.1 +notebook==7.2.1 +notebook_shim==0.2.4 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.18.1 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +omegaconf==2.3.0 +open-clip-torch==2.24.0 +overrides==7.7.0 +packaging==24.1 +pandas==2.2.0 +pandocfilters==1.5.1 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.3.0 +pip==24.0 +platformdirs==4.2.2 +prometheus_client==0.20.0 +prompt_toolkit==3.0.47 +protobuf==5.27.1 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +pyarrow-hotfix==0.6 +pyarrow==15.0.2 +pycparser==2.22 +pydantic==2.7.4 +pydantic_core==2.18.4 +pynvml==11.5.0 +pyparsing==3.1.2 +python-dateutil==2.9.0.post0 +python-json-logger==2.0.7 +pytorch-lightning==2.0.1 +pytorch-warmup==0.1.1 +pytz==2024.1 +pyzmq==26.0.3 +qtconsole==5.5.2 +referencing==0.35.1 +regex==2024.5.15 +requests==2.32.3 +resize-right==0.0.2 +responses==0.18.0 +rfc3339-validator==0.1.4 +rfc3986-validator==0.1.1 +rotary-embedding-torch==0.6.2 +rouge_score==0.1.2 +rpds-py==0.18.1 +safetensors==0.4.3 +scikit-image==0.22.0 +scikit-learn==1.5.0 +scipy==1.13.1 +sentence-transformers==2.5.1 +sentencepiece==0.2.0 +sentry-sdk==2.5.1 +setproctitle==1.3.3 +setuptools==65.5.0 +six==1.16.0 +smmap==5.0.1 +sniffio==1.3.1 +soupsieve==2.5 +stack-data==0.6.3 +sympy==1.12.1 +terminado==0.18.1 +threadpoolctl==3.5.0 +tifffile==2024.5.22 +timm==1.0.3 +tinycss2==1.3.0 +tokenizers==0.15.2 +torch-fidelity==0.3.0 +torch==2.1.0 +torchmetrics==1.3.0.post0 +torchvision==0.16.0 +tornado==6.4.1 +tqdm==4.66.4 +traitlets==5.14.3 +transformers==4.37.2 +triton==2.1.0 +types-python-dateutil==2.9.0.20240316 +typing_extensions==4.12.2 +tzdata==2024.1 +umap==0.1.1 +uri-template==1.3.0 +urllib3==2.2.1 +vector-quantize-pytorch==1.14.24 +wandb==0.17.1 +wcwidth==0.2.13 +webcolors==24.6.0 +webdataset==0.2.73 +webencodings==0.5.1 +websocket-client==1.8.0 +widgetsnbextension==4.0.11 +x-clip==0.14.4 +xformers==0.0.22.post7 +xxhash==3.4.1 +yarl==1.9.4 +zipp==3.19.2 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/wandb-metadata.json b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..bdde43c43e35305e16041064f1c1e9614fa1bc99 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/wandb-metadata.json @@ -0,0 +1,1057 @@ +{ + "os": "Linux-5.15.0-1058-aws-x86_64-with-glibc2.31", + "python": "3.11.9", + "heartbeatAt": "2024-06-18T12:16:14.300329", + "startedAt": "2024-06-18T12:16:13.354272", + "docker": null, + "cuda": null, + "args": [ + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset", + "--cache_dir=/weka/proj-medarc/shared/cache", + "--model_name=rr-test", + "--multi_subject", + "--subj=1", + "--batch_size=21", + "--max_lr=3e-4", + "--mixup_pct=.33", + "--num_epochs=150", + "--prior_scale=30", + "--clip_scale=1", + "--no-blurry_recon", + "--blur_scale=.5", + "--no-use_image_aug", + "--n_blocks=4", + "--hidden_dim=1024", + "--num_sessions=40", + "--ckpt_interval=999", + "--ckpt_saving", + "--wandb_log" + ], + "state": "running", + "program": "/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py", + "codePathLocal": "TrainCluster.py", + "codePath": "src/TrainCluster.py", + "git": { + "remote": "https://github.com/MedARC-AI/MindEyeV2.git", + "commit": "a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe" + }, + "email": null, + "root": "/weka/proj-fmri/ckadirt/MindEyeV2", + "host": "ip-10-0-154-61", + "username": "ckadirt", + "executable": "/admin/home-ckadirt/fmri/bin/python3.11", + "cpu_count": 96, + "cpu_count_logical": 192, + "cpu_freq": { + "current": 2694.2966979166763, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3112.839, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.447, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.107, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3596.856, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.522, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.648, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.753, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.438, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.905, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3362.07, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3374.828, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 232.4169158935547, + "used": 170.42882919311523 + } + }, + "gpu": "NVIDIA H100 80GB HBM3", + "gpu_count": 8, + "gpu_devices": [ + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 1999.962516784668 + } +} diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug-internal.log b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..af39abdace529ad8340d4749139f320390a142ce --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug-internal.log @@ -0,0 +1,52 @@ +2024-06-18 12:16:13,467 INFO StreamThr :828956 [internal.py:wandb_internal():85] W&B internal server running at pid: 828956, started at: 2024-06-18 12:16:13.463596 +2024-06-18 12:16:13,468 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: status +2024-06-18 12:16:13,492 INFO WriterThread:828956 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/run-rr-test.wandb +2024-06-18 12:16:13,496 DEBUG SenderThread:828956 [sender.py:send():379] send: header +2024-06-18 12:16:13,562 DEBUG SenderThread:828956 [sender.py:send():379] send: run +2024-06-18 12:16:13,574 INFO SenderThread:828956 [sender.py:_setup_resume():749] checking resume status for None/mindeye_semantic_cluster/rr-test +2024-06-18 12:16:14,023 INFO SenderThread:828956 [dir_watcher.py:__init__():211] watching files in: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files +2024-06-18 12:16:14,023 INFO SenderThread:828956 [sender.py:_start_run_threads():1188] run started: rr-test with start time 1718712973.469764 +2024-06-18 12:16:14,048 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: check_version +2024-06-18 12:16:14,048 DEBUG SenderThread:828956 [sender.py:send_request():406] send_request: check_version +2024-06-18 12:16:14,148 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: run_start +2024-06-18 12:16:14,236 DEBUG HandlerThread:828956 [system_info.py:__init__():26] System info init +2024-06-18 12:16:14,236 DEBUG HandlerThread:828956 [system_info.py:__init__():41] System info init done +2024-06-18 12:16:14,236 INFO HandlerThread:828956 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:16:14,237 INFO SystemMonitor:828956 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:16:14,237 INFO HandlerThread:828956 [system_monitor.py:probe():214] Collecting system info +2024-06-18 12:16:14,237 INFO SystemMonitor:828956 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:16:14,238 INFO SystemMonitor:828956 [interfaces.py:start():188] Started disk monitoring +2024-06-18 12:16:14,238 INFO SystemMonitor:828956 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 12:16:14,239 INFO SystemMonitor:828956 [interfaces.py:start():188] Started memory monitoring +2024-06-18 12:16:14,239 INFO SystemMonitor:828956 [interfaces.py:start():188] Started network monitoring +2024-06-18 12:16:14,300 DEBUG HandlerThread:828956 [system_info.py:probe():152] Probing system +2024-06-18 12:16:14,308 DEBUG HandlerThread:828956 [system_info.py:_probe_git():137] Probing git +2024-06-18 12:16:14,331 DEBUG HandlerThread:828956 [system_info.py:_probe_git():145] Probing git done +2024-06-18 12:16:14,331 DEBUG HandlerThread:828956 [system_info.py:probe():200] Probing system done +2024-06-18 12:16:14,332 DEBUG HandlerThread:828956 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-1058-aws-x86_64-with-glibc2.31', 'python': '3.11.9', 'heartbeatAt': '2024-06-18T12:16:14.300329', 'startedAt': '2024-06-18T12:16:13.354272', 'docker': None, 'cuda': None, 'args': ('--data_path=/weka/proj-medarc/shared/mindeyev2_dataset', '--cache_dir=/weka/proj-medarc/shared/cache', '--model_name=rr-test', '--multi_subject', '--subj=1', '--batch_size=21', '--max_lr=3e-4', '--mixup_pct=.33', '--num_epochs=150', '--prior_scale=30', '--clip_scale=1', '--no-blurry_recon', '--blur_scale=.5', '--no-use_image_aug', '--n_blocks=4', '--hidden_dim=1024', '--num_sessions=40', '--ckpt_interval=999', '--ckpt_saving', '--wandb_log'), 'state': 'running', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py', 'codePathLocal': 'TrainCluster.py', 'codePath': 'src/TrainCluster.py', 'git': {'remote': 'https://github.com/MedARC-AI/MindEyeV2.git', 'commit': 'a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe'}, 'email': None, 'root': '/weka/proj-fmri/ckadirt/MindEyeV2', 'host': 'ip-10-0-154-61', 'username': 'ckadirt', 'executable': '/admin/home-ckadirt/fmri/bin/python3.11', 'cpu_count': 96, 'cpu_count_logical': 192, 'cpu_freq': {'current': 2694.2966979166763, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3112.839, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3597.447, 'min': 0.0, 'max': 0.0}, {'current': 3597.107, 'min': 0.0, 'max': 0.0}, {'current': 3596.856, 'min': 0.0, 'max': 0.0}, {'current': 3597.522, 'min': 0.0, 'max': 0.0}, {'current': 3597.648, 'min': 0.0, 'max': 0.0}, {'current': 3598.753, 'min': 0.0, 'max': 0.0}, {'current': 3598.438, 'min': 0.0, 'max': 0.0}, {'current': 3597.905, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3362.07, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3374.828, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 232.4169158935547, 'used': 170.42882919311523}}, 'gpu': 'NVIDIA H100 80GB HBM3', 'gpu_count': 8, 'gpu_devices': [{'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}], 'memory': {'total': 1999.962516784668}} +2024-06-18 12:16:14,332 INFO HandlerThread:828956 [system_monitor.py:probe():224] Finished collecting system info +2024-06-18 12:16:14,332 INFO HandlerThread:828956 [system_monitor.py:probe():227] Publishing system info +2024-06-18 12:16:14,332 DEBUG HandlerThread:828956 [system_info.py:_save_code():44] Saving code +2024-06-18 12:16:14,365 DEBUG HandlerThread:828956 [system_info.py:_save_code():67] Saving code done +2024-06-18 12:16:14,365 DEBUG HandlerThread:828956 [system_info.py:_save_patches():84] Saving git patches +2024-06-18 12:16:15,014 DEBUG HandlerThread:828956 [system_info.py:_save_patches():126] Saving git patches done +2024-06-18 12:16:15,021 INFO HandlerThread:828956 [system_monitor.py:probe():229] Finished publishing system info +2024-06-18 12:16:15,033 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/diff.patch +2024-06-18 12:16:15,033 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code/src/TrainCluster.py +2024-06-18 12:16:15,033 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/wandb-metadata.json +2024-06-18 12:16:15,033 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code/src +2024-06-18 12:16:15,033 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/code +2024-06-18 12:16:15,039 DEBUG SenderThread:828956 [sender.py:send():379] send: files +2024-06-18 12:16:15,040 INFO SenderThread:828956 [sender.py:_save_file():1454] saving file wandb-metadata.json with policy now +2024-06-18 12:16:15,040 INFO SenderThread:828956 [sender.py:_save_file():1454] saving file code/src/TrainCluster.py with policy now +2024-06-18 12:16:15,040 INFO SenderThread:828956 [sender.py:_save_file():1454] saving file diff.patch with policy now +2024-06-18 12:16:15,566 INFO wandb-upload_0:828956 [upload_job.py:push():130] Uploaded file /tmp/tmp9o0_c5jjwandb/05oxlsji-wandb-metadata.json +2024-06-18 12:16:15,628 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: python_packages +2024-06-18 12:16:15,629 DEBUG SenderThread:828956 [sender.py:send_request():406] send_request: python_packages +2024-06-18 12:16:15,629 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:16:15,630 DEBUG HandlerThread:828956 [handler.py:handle_request():158] handle_request: internal_messages +2024-06-18 12:16:15,635 DEBUG SenderThread:828956 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:16:15,811 DEBUG SenderThread:828956 [sender.py:send():379] send: telemetry +2024-06-18 12:16:15,866 INFO wandb-upload_2:828956 [upload_job.py:push():130] Uploaded file /tmp/tmp9o0_c5jjwandb/xypu7qg2-diff.patch +2024-06-18 12:16:15,886 INFO wandb-upload_1:828956 [upload_job.py:push():130] Uploaded file /tmp/tmp9o0_c5jjwandb/z7aiv2ba-code/src/TrainCluster.py +2024-06-18 12:16:16,048 INFO Thread-12 :828956 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/files/requirements.txt diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug.log b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..ed0beebecf27f1ad984c1ccff1f564a6b5a27ee2 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug.log @@ -0,0 +1,28 @@ +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Configure stats pid to 828664 +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False} +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': 'src/TrainCluster.py', 'program_abspath': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainCluster.py'} +2024-06-18 12:16:13,451 INFO MainThread:828664 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-06-18 12:16:13,452 INFO MainThread:828664 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug.log +2024-06-18 12:16:13,453 INFO MainThread:828664 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_121613-rr-test/logs/debug-internal.log +2024-06-18 12:16:13,453 INFO MainThread:828664 [wandb_init.py:init():560] calling init triggers +2024-06-18 12:16:13,453 INFO MainThread:828664 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'rr-test', 'global_batch_size': '21', 'batch_size': 3, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 573919937, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 3750, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': True, 'num_devices': 8, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar'} +2024-06-18 12:16:13,453 INFO MainThread:828664 [wandb_init.py:init():610] starting backend +2024-06-18 12:16:13,453 INFO MainThread:828664 [wandb_init.py:init():614] setting up manager +2024-06-18 12:16:13,462 INFO MainThread:828664 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-06-18 12:16:13,468 INFO MainThread:828664 [wandb_init.py:init():622] backend started and connected +2024-06-18 12:16:13,492 INFO MainThread:828664 [wandb_init.py:init():711] updated telemetry +2024-06-18 12:16:13,562 INFO MainThread:828664 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-06-18 12:16:14,047 INFO MainThread:828664 [wandb_run.py:_on_init():2402] communicating current version +2024-06-18 12:16:14,091 INFO MainThread:828664 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.2 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-06-18 12:16:14,092 INFO MainThread:828664 [wandb_init.py:init():795] starting run threads in backend +2024-06-18 12:16:15,629 INFO MainThread:828664 [wandb_run.py:_console_start():2380] atexit reg +2024-06-18 12:16:15,629 INFO MainThread:828664 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-06-18 12:16:15,630 INFO MainThread:828664 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-06-18 12:16:15,630 INFO MainThread:828664 [wandb_run.py:_redirect():2325] Redirects installed. +2024-06-18 12:16:15,638 INFO MainThread:828664 [wandb_init.py:init():838] run started, returning control to user process diff --git a/MindEyeV2/src/wandb/run-20240618_121613-rr-test/run-rr-test.wandb b/MindEyeV2/src/wandb/run-20240618_121613-rr-test/run-rr-test.wandb new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9a78c69cc1582ceff8b5419db3049ef831d43322 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +model_name: + desc: null + value: testing +global_batch_size: + desc: null + value: 8 +batch_size: + desc: null + value: 8 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 40 +num_params: + desc: null + value: 486928065 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 0.0003 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 30000 +num_test: + desc: null + value: 3000 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: false +seed: + desc: null + value: 42 +distributed: + desc: null + value: false +num_devices: + desc: null + value: 1 +world_size: + desc: null + value: 1 +train_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar +test_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar +_wandb: + desc: null + value: + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: true + is_kaggle_kernel: false + start_time: 1718714174 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 2: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 13 + - 14 + - 16 + - 23 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 1 + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/diff.patch b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/diff.patch new file mode 100644 index 0000000000000000000000000000000000000000..922a5cb8ff737258d8ab11f05258795d4732b6d0 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/diff.patch @@ -0,0 +1,239 @@ +diff --git a/src/Train.ipynb b/src/Train.ipynb +index 91922c8..396549d 100644 +--- a/src/Train.ipynb ++++ b/src/Train.ipynb +@@ -99,7 +99,7 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "PID of this process = 3001293\n", ++ "PID of this process = 3520819\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", +@@ -1362,9 +1362,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { +diff --git a/src/accel.slurm b/src/accel.slurm +index 1c1dfbc..50097be 100644 +--- a/src/accel.slurm ++++ b/src/accel.slurm +@@ -1,7 +1,7 @@ + #!/bin/bash +-#SBATCH --account=topfmri +-#SBATCH --partition=a40x +-#SBATCH --job-name=eye ++#SBATCH --account=fmri ++#SBATCH --partition=p5 ++#SBATCH --job-name=eyeRR + #SBATCH --nodes=1 + #SBATCH --gres=gpu:1 + #SBATCH --time=48:00:00 # total run time limit (HH:MM:SS) +@@ -12,11 +12,11 @@ + #SBATCH --exclusive + + # Make sure you activate your fmri environment created from src/setup.sh +-cd /weka/proj-fmri/paulscotti/MindEyeV2/src +-source fmri/bin/activate ++cd /weka/proj-fmri/ckadirt/MindEyeV2/src ++source /admin/home-ckadirt/fmri/bin/activate + + # The following line converts your jupyter notebook into a python script runnable with Slurm +-jupyter nbconvert Train.ipynb --to python ++jupyter nbconvert TrainCluster.ipynb --to python + + export NUM_GPUS=1 # Set to equal gres=gpu:#! + export BATCH_SIZE=21 # 21 for multisubject / 24 for singlesubject (orig. paper used 42 for multisubject / 24 for singlesubject) +@@ -26,16 +26,16 @@ export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") + export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +-export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) ++export COUNT_NODE=1 #$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + echo MASTER_ADDR=${MASTER_ADDR} + echo MASTER_PORT=${MASTER_PORT} + echo WORLD_SIZE=${COUNT_NODE} + + # multisubject pretraining +-model_name="multisubject_excludingsubj01_40sess" ++model_name="rr-test" + echo model_name=${model_name} +-accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +- ++# accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log ++python TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log + # singlesubject finetuning + #model_name="finetuned_subj01_40sess" + #echo model_name=${model_name} +diff --git a/src/recon_inference.ipynb b/src/recon_inference.ipynb +index 10d7e27..0593e7e 100644 +--- a/src/recon_inference.ipynb ++++ b/src/recon_inference.ipynb +@@ -12,7 +12,6 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "LOCAL RANK 0\n", + "device: cuda\n" + ] + } +@@ -60,7 +59,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 33, ++ "execution_count": 2, + "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8", + "metadata": { + "tags": [] +@@ -71,9 +70,7 @@ + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_40sess_24bs\n", +- "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n", +- "The autoreload extension is already loaded. To reload it, use:\n", +- " %reload_ext autoreload\n" ++ "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n" + ] + } + ], +@@ -99,7 +96,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 34, ++ "execution_count": 3, + "id": "49e5dae4-606d-4dc6-b420-df9e4c14737e", + "metadata": { + "tags": [] +@@ -157,7 +154,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 35, ++ "execution_count": 4, + "id": "64672583-9f00-46f5-8d4e-00e4c7068a1d", + "metadata": { + "tags": [] +@@ -221,7 +218,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 36, ++ "execution_count": 5, + "id": "a3cbeea8-e95b-48d9-9bc2-91af260c93d1", + "metadata": {}, + "outputs": [ +@@ -254,39 +251,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 38, ++ "execution_count": null, + "id": "3afc4858-b6a6-4a52-9303-b4a50ea5cc0b", + "metadata": {}, +- "outputs": [ +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "param counts:\n", +- "83,653,863 total\n", +- "0 trainable\n", +- "param counts:\n", +- "64,409,600 total\n", +- "64,409,600 trainable\n", +- "param counts:\n", +- "1,903,020,028 total\n", +- "1,903,020,028 trainable\n", +- "param counts:\n", +- "1,967,429,628 total\n", +- "1,967,429,628 trainable\n", +- "param counts:\n", +- "259,865,216 total\n", +- "259,865,200 trainable\n", +- "param counts:\n", +- "2,227,294,844 total\n", +- "2,227,294,828 trainable\n", +- "\n", +- "---loading /weka/proj-fmri/paulscotti/MindEye2_git/train_logs/final_subj01_pretrained_40sess_24bs/last.pth ckpt---\n", +- "\n", +- "ckpt loaded!\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", +@@ -393,7 +361,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 30, ++ "execution_count": null, + "id": "295824db-ab3d-450c-90fb-f656e48994ba", + "metadata": { + "tags": [] +@@ -430,38 +398,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 31, ++ "execution_count": null, + "id": "f726f617-39f5-49e2-8d0c-d11d27d01c30", + "metadata": {}, +- "outputs": [ +- { +- "name": "stderr", +- "output_type": "stream", +- "text": [ +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n" +- ] +- }, +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False\n", +- "Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "vector_suffix torch.Size([1, 1024])\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "# prep unCLIP\n", + "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n", +@@ -715,9 +655,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..43215aed6a4663b6b137ad2b3963eef9aee4e4d3 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log @@ -0,0 +1,2007 @@ +3750 +testing starting with epoch 0 / 150 + 0%| | 0/150 [00:00) tensor([10, 2, 17, 19, 17, 33, 39, 7]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-5.8375e+01, -5.6219e+01, 6.3050e+02, -1.2968e+04, -1.1392e+04, + -1.3368e+04, -5.7906e+01, 6.7250e+02, -1.3925e+02, -8.1188e+01, + 5.7550e+02, -7.1875e+01, -5.9281e+01, -7.5750e+01, -3.9600e+03, + -1.2784e+04, -4.8480e+03, 6.6150e+02, -1.4275e+02, 4.7700e+02, + -5.1406e+01, -5.6750e+01, -1.1262e+02, -8.9875e+01, -8.5375e+01, + -1.0806e+02, -7.4750e+01, -6.6250e+01, -9.2500e+01, -9.8560e+03, + -6.1375e+01, -8.0188e+01, -1.2381e+02, 8.4250e+02, -1.3950e+02, + -6.9438e+01, -5.9062e+01, -1.2696e+04, -1.1384e+04, 4.9125e+02, + -9.0438e+01], + [-3.9500e+01, -4.3594e+01, 2.1175e+02, -4.8720e+03, -4.6560e+03, + -4.3040e+03, -4.5094e+01, 1.9525e+02, -7.6250e+01, -6.0312e+01, + 2.1438e+02, -4.7344e+01, -4.5781e+01, -5.4750e+01, -1.5930e+03, + -5.2120e+03, -1.8870e+03, 2.6675e+02, -9.1188e+01, 3.1225e+02, + -3.6219e+01, -4.1531e+01, -8.1375e+01, -6.4062e+01, -6.8562e+01, + -7.6938e+01, -5.5406e+01, -5.6219e+01, -7.4938e+01, -4.5400e+03, + -5.4031e+01, -6.2031e+01, -7.8000e+01, 2.0450e+02, -1.0506e+02, + -5.6000e+01, -4.4719e+01, -5.0120e+03, -4.8160e+03, 2.8250e+02, + -7.7250e+01], + [-1.8922e+01, -1.6844e+01, 2.4350e+02, -6.1840e+03, -5.5200e+03, + -6.0960e+03, -2.0562e+01, 2.7925e+02, -6.5750e+01, -3.1875e+01, + 3.2150e+02, -2.9812e+01, -2.1000e+01, -2.7719e+01, -2.3080e+03, + -6.2000e+03, -2.4720e+03, 2.9975e+02, -6.8188e+01, 2.7225e+02, + -1.6281e+01, -1.8844e+01, -4.6938e+01, -3.6500e+01, -3.4969e+01, + -4.6469e+01, -2.5469e+01, -2.3250e+01, -3.8219e+01, -5.1440e+03, + -1.9781e+01, -3.0375e+01, -5.7156e+01, 2.6050e+02, -6.7375e+01, + -2.6641e+01, -1.8984e+01, -6.3080e+03, -5.8520e+03, 3.2100e+02, + -3.5344e+01], + [-5.8125e+01, -6.1156e+01, 4.2825e+02, -8.5760e+03, -7.0320e+03, + -9.4240e+03, -6.3938e+01, 4.6350e+02, -1.2619e+02, -7.9812e+01, + 3.8800e+02, -7.8688e+01, -6.3719e+01, -7.5438e+01, -2.9160e+03, + -8.2400e+03, -3.4580e+03, 4.5225e+02, -1.2988e+02, 3.0175e+02, + -5.7844e+01, -6.0062e+01, -1.0538e+02, -8.9312e+01, -8.6625e+01, + -9.9562e+01, -7.6062e+01, -6.6062e+01, -9.0625e+01, -5.8920e+03, + -6.5062e+01, -8.3812e+01, -1.1431e+02, 5.4000e+02, -1.3225e+02, + -7.1312e+01, -6.3156e+01, -8.3760e+03, -6.9200e+03, 4.2325e+02, + -8.8688e+01], + [-1.1516e+01, -8.8672e+00, 1.3075e+02, -3.1900e+03, -2.7680e+03, + -2.7400e+03, -6.4727e+00, 6.6125e+01, -2.3828e+01, -1.0836e+01, + 6.5438e+01, -1.5422e+01, -1.0023e+01, -1.3641e+01, -9.2050e+02, + -2.9680e+03, -1.1730e+03, 1.0862e+02, -1.9703e+01, 9.2500e+01, + -9.8125e+00, -9.4453e+00, -1.8172e+01, -1.6438e+01, -1.4281e+01, + -1.8922e+01, -1.6438e+01, -8.4453e+00, -1.2859e+01, -2.5140e+03, + -7.5078e+00, -1.3641e+01, -1.7938e+01, 4.9875e+01, -1.9797e+01, + -9.2891e+00, -1.0148e+01, -1.7190e+03, -2.4160e+03, 1.2650e+02, + -1.5289e+01], + [-7.6625e+01, -7.7125e+01, 3.0550e+02, -8.5120e+03, -7.3640e+03, + -8.5840e+03, -7.7000e+01, 4.5775e+02, -1.4162e+02, -9.6000e+01, + 4.5350e+02, -8.8812e+01, -7.9812e+01, -9.6750e+01, -2.9460e+03, + -8.9200e+03, -3.3860e+03, 5.1800e+02, -1.4325e+02, 4.5450e+02, + -7.2125e+01, -7.5312e+01, -1.2519e+02, -1.0631e+02, -1.0175e+02, + -1.2175e+02, -9.9062e+01, -8.5062e+01, -1.0481e+02, -7.3000e+03, + -8.2938e+01, -1.0406e+02, -1.3038e+02, 4.8775e+02, -1.4888e+02, + -8.8438e+01, -8.0625e+01, -9.7040e+03, -8.7600e+03, 3.5475e+02, + -1.1019e+02], + [-7.5586e+00, -5.9922e+00, 2.1525e+02, -2.7580e+03, -2.6780e+03, + -3.7700e+03, -1.0531e+01, 1.9288e+02, -1.8219e+01, -1.3422e+01, + 1.2419e+02, -1.2305e+01, -1.0953e+01, -1.0047e+01, -9.7000e+02, + -2.5360e+03, -1.0410e+03, 7.0438e+01, -1.9453e+01, 2.3562e+02, + -8.5000e+00, -9.2969e+00, -1.5680e+01, -1.3938e+01, -1.4445e+01, + -1.7469e+01, -9.5781e+00, -9.4141e+00, -1.4820e+01, -2.1500e+03, + -7.2773e+00, -1.2375e+01, -1.6875e+01, 7.7375e+01, -2.0547e+01, + -9.4844e+00, -8.4219e+00, -2.6280e+03, -2.8660e+03, 1.1594e+02, + -1.2078e+01], + [-4.0562e+01, -3.9000e+01, 2.7675e+02, -7.8840e+03, -7.3560e+03, + -7.9160e+03, -4.1438e+01, 4.2200e+02, -1.0156e+02, -5.8938e+01, + 4.5000e+02, -4.8875e+01, -4.1031e+01, -5.3656e+01, -3.0420e+03, + -8.4480e+03, -3.3240e+03, 3.9350e+02, -1.0594e+02, 3.8975e+02, + -3.5969e+01, -3.6562e+01, -8.2938e+01, -6.5000e+01, -6.2906e+01, + -8.2625e+01, -5.1281e+01, -4.8719e+01, -6.9438e+01, -7.3000e+03, + -4.5281e+01, -5.8188e+01, -9.2812e+01, 3.2475e+02, -1.0894e+02, + -5.1500e+01, -4.0500e+01, -8.8720e+03, -8.3600e+03, 4.4000e+02, + -6.9188e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 10, 17, 33, 39, 7, 19, 2]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-3.7281e+01, -3.7344e+01, 3.6350e+02, -4.9360e+03, -4.7080e+03, + -6.7320e+03, -4.4344e+01, 2.3112e+02, -9.9500e+01, -5.8625e+01, + 2.3488e+02, -5.6219e+01, -4.5312e+01, -5.1688e+01, -2.1380e+03, + -5.8160e+03, -2.5440e+03, 3.3500e+02, -1.0662e+02, 1.6062e+02, + -3.7469e+01, -4.0594e+01, -8.7875e+01, -6.5500e+01, -6.5438e+01, + -8.2875e+01, -4.9906e+01, -4.9969e+01, -6.8188e+01, -3.9820e+03, + -4.7375e+01, -5.9812e+01, -9.3312e+01, 1.7762e+02, -1.1231e+02, + -4.8562e+01, -4.1844e+01, -6.1120e+03, -5.5120e+03, 4.3675e+02, + -7.3188e+01], + [-3.2281e+01, -2.7922e+01, 2.1325e+02, -8.1600e+03, -7.3120e+03, + -5.8640e+03, -2.8906e+01, 3.7750e+02, -9.0688e+01, -4.3344e+01, + 2.4375e+02, -3.7000e+01, -2.9547e+01, -3.8938e+01, -2.6340e+03, + -8.4000e+03, -3.3560e+03, 3.5975e+02, -9.2375e+01, 3.8800e+02, + -2.8797e+01, -2.6734e+01, -6.5125e+01, -4.8031e+01, -4.4656e+01, + -6.7500e+01, -3.8438e+01, -3.3531e+01, -5.3719e+01, -7.3680e+03, + -3.1625e+01, -3.9219e+01, -7.8375e+01, 2.2075e+02, -8.9875e+01, + -3.6844e+01, -2.9328e+01, -7.8520e+03, -8.2800e+03, 5.3350e+02, + -4.3625e+01], + [-6.3906e+01, -7.0000e+01, 3.3375e+02, -5.4000e+03, -5.1440e+03, + -5.9040e+03, -7.1750e+01, 3.1725e+02, -1.3375e+02, -9.5312e+01, + 2.4912e+02, -7.3125e+01, -6.9625e+01, -8.8312e+01, -2.2500e+03, + -6.4040e+03, -2.4800e+03, 3.5050e+02, -1.5288e+02, 3.1350e+02, + -6.1406e+01, -6.3812e+01, -1.3000e+02, -1.0288e+02, -1.0262e+02, + -1.2575e+02, -8.7000e+01, -8.6688e+01, -1.0981e+02, -5.6160e+03, + -8.3875e+01, -1.0106e+02, -1.3412e+02, 2.4725e+02, -1.6888e+02, + -8.3562e+01, -7.2125e+01, -6.8720e+03, -6.5720e+03, 4.1125e+02, + -1.1900e+02], + [-6.2938e+01, -6.8438e+01, 3.4600e+02, -5.5160e+03, -5.2320e+03, + -6.0560e+03, -7.0000e+01, 3.1850e+02, -1.3325e+02, -9.3312e+01, + 2.6325e+02, -7.1188e+01, -6.7750e+01, -8.6562e+01, -2.2600e+03, + -6.4720e+03, -2.5180e+03, 3.5875e+02, -1.5162e+02, 3.1625e+02, + -5.9969e+01, -6.2250e+01, -1.2744e+02, -1.0062e+02, -1.0031e+02, + -1.2362e+02, -8.4875e+01, -8.4750e+01, -1.0756e+02, -5.6640e+03, + -8.1812e+01, -9.8312e+01, -1.3300e+02, 2.5062e+02, -1.6625e+02, + -8.1875e+01, -7.0375e+01, -6.9880e+03, -6.6560e+03, 4.0650e+02, + -1.1594e+02], + [-5.8938e+01, -5.5031e+01, 5.7500e+02, -1.4024e+04, -1.2120e+04, + -1.3104e+04, -6.1219e+01, 6.1850e+02, -1.4012e+02, -7.9812e+01, + 6.4550e+02, -7.9625e+01, -6.3344e+01, -7.3438e+01, -4.3160e+03, + -1.3344e+04, -4.9760e+03, 8.3450e+02, -1.3850e+02, 5.8450e+02, + -5.5719e+01, -5.9281e+01, -1.0675e+02, -9.0062e+01, -8.6562e+01, + -1.0725e+02, -7.4500e+01, -6.1875e+01, -9.2688e+01, -1.1288e+04, + -5.9125e+01, -7.8625e+01, -1.2356e+02, 6.9400e+02, -1.3575e+02, + -7.1375e+01, -6.0312e+01, -1.3984e+04, -1.2248e+04, 5.7000e+02, + -8.6812e+01], + [-1.5688e+01, -1.8344e+01, 1.1975e+02, -2.2320e+03, -2.0780e+03, + -2.9360e+03, -1.9406e+01, 1.0144e+02, -4.0875e+01, -2.6000e+01, + 1.6588e+02, -2.0500e+01, -1.7656e+01, -2.2828e+01, -6.8850e+02, + -2.4060e+03, -9.6350e+02, 1.8212e+02, -4.6875e+01, 1.2681e+02, + -1.4555e+01, -1.5781e+01, -3.7156e+01, -2.8594e+01, -3.2188e+01, + -3.3688e+01, -2.0531e+01, -2.2750e+01, -3.3000e+01, -2.3560e+03, + -2.2797e+01, -2.7438e+01, -3.8594e+01, 1.3850e+02, -5.1812e+01, + -2.2047e+01, -1.9156e+01, -2.6760e+03, -2.0920e+03, 1.1831e+02, + -3.3594e+01], + [-7.7688e+01, -7.7250e+01, 6.9650e+02, -1.4488e+04, -1.2064e+04, + -1.4248e+04, -8.0625e+01, 7.0300e+02, -1.7625e+02, -1.0231e+02, + 7.9550e+02, -1.0475e+02, -8.5750e+01, -9.5062e+01, -4.7440e+03, + -1.3432e+04, -5.4160e+03, 8.5850e+02, -1.7238e+02, 4.1800e+02, + -7.6938e+01, -8.2750e+01, -1.3175e+02, -1.1388e+02, -1.0856e+02, + -1.2875e+02, -9.6438e+01, -8.0875e+01, -1.1188e+02, -1.0416e+04, + -7.8938e+01, -1.0125e+02, -1.5238e+02, 8.2650e+02, -1.6450e+02, + -9.3688e+01, -8.2125e+01, -1.4728e+04, -1.1576e+04, 5.0100e+02, + -1.0581e+02], + [-1.8219e+01, -2.1312e+01, 1.2500e+02, -2.3040e+03, -2.0860e+03, + -3.0180e+03, -2.2531e+01, 9.6812e+01, -4.5156e+01, -2.9250e+01, + 1.7238e+02, -2.4172e+01, -2.1000e+01, -2.6203e+01, -7.0100e+02, + -2.4600e+03, -9.7050e+02, 1.8562e+02, -5.1125e+01, 1.3612e+02, + -1.7734e+01, -1.9047e+01, -4.0844e+01, -3.2281e+01, -3.5688e+01, + -3.7438e+01, -2.4031e+01, -2.5562e+01, -3.6000e+01, -2.4260e+03, + -2.5625e+01, -3.0906e+01, -4.2406e+01, 1.5175e+02, -5.5688e+01, + -2.5203e+01, -2.2594e+01, -2.8040e+03, -2.1240e+03, 1.2050e+02, + -3.6719e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([ 7, 33, 17, 2, 17, 19, 39, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-7.9750e+01, -7.9438e+01, 6.1000e+02, -1.1776e+04, -9.5840e+03, + -1.1376e+04, -7.9938e+01, 5.6050e+02, -1.6300e+02, -1.0369e+02, + 5.7100e+02, -9.3938e+01, -8.1250e+01, -9.9875e+01, -3.8700e+03, + -1.0696e+04, -4.4800e+03, 7.5700e+02, -1.6875e+02, 4.5700e+02, + -7.4188e+01, -7.7125e+01, -1.3588e+02, -1.1288e+02, -1.0969e+02, + -1.3450e+02, -1.0294e+02, -8.8875e+01, -1.1588e+02, -9.9840e+03, + -8.7125e+01, -1.0600e+02, -1.4888e+02, 6.1200e+02, -1.7062e+02, + -9.4312e+01, -8.1938e+01, -1.1464e+04, -1.0080e+04, 4.8825e+02, + -1.1944e+02], + [-4.5594e+01, -4.2969e+01, 3.9800e+02, -1.0224e+04, -8.9360e+03, + -9.9760e+03, -4.7094e+01, 4.9825e+02, -1.1131e+02, -6.3062e+01, + 4.4050e+02, -6.1156e+01, -4.9594e+01, -5.5656e+01, -3.4620e+03, + -1.0360e+04, -3.9160e+03, 5.5950e+02, -1.0931e+02, 4.0450e+02, + -4.4312e+01, -4.5188e+01, -8.4062e+01, -6.8562e+01, -6.4938e+01, + -8.2500e+01, -5.4281e+01, -4.8938e+01, -7.2062e+01, -8.8160e+03, + -4.5875e+01, -5.6094e+01, -9.5750e+01, 5.9750e+02, -1.0544e+02, + -5.6219e+01, -4.6219e+01, -1.0320e+04, -9.5520e+03, 5.1050e+02, + -6.5750e+01], + [-4.2312e+01, -4.6531e+01, 3.5825e+02, -7.9480e+03, -6.3120e+03, + -7.4600e+03, -5.0875e+01, 3.5350e+02, -1.0319e+02, -7.0250e+01, + 4.4525e+02, -5.7938e+01, -4.8719e+01, -5.8062e+01, -2.4140e+03, + -7.2440e+03, -2.9380e+03, 4.0775e+02, -1.1588e+02, 1.8688e+02, + -4.2125e+01, -4.5406e+01, -9.2812e+01, -7.4875e+01, -7.6500e+01, + -8.7125e+01, -5.6812e+01, -5.7281e+01, -8.2812e+01, -5.6280e+03, + -5.6688e+01, -6.8750e+01, -9.7500e+01, 4.3675e+02, -1.2519e+02, + -6.1188e+01, -4.6438e+01, -7.7000e+03, -6.4600e+03, 3.5225e+02, + -7.9812e+01], + [-5.6938e+01, -5.4688e+01, 2.8675e+02, -6.8800e+03, -5.8480e+03, + -5.6680e+03, -5.6750e+01, 3.8025e+02, -1.1931e+02, -7.5250e+01, + 3.3125e+02, -6.3281e+01, -5.6625e+01, -7.2250e+01, -2.4600e+03, + -6.4960e+03, -2.7800e+03, 4.2000e+02, -1.2644e+02, 1.7212e+02, + -5.0438e+01, -5.4000e+01, -9.8375e+01, -8.0250e+01, -7.5938e+01, + -9.8000e+01, -7.4500e+01, -6.4750e+01, -8.4938e+01, -5.7800e+03, + -6.1062e+01, -7.4562e+01, -1.1025e+02, 3.1850e+02, -1.2625e+02, + -6.8438e+01, -5.6031e+01, -7.5840e+03, -7.0040e+03, 3.3150e+02, + -8.5062e+01], + [-3.8312e+01, -3.3469e+01, 4.3350e+02, -1.0912e+04, -9.5120e+03, + -1.0376e+04, -3.6500e+01, 4.7600e+02, -1.0450e+02, -5.3000e+01, + 3.9850e+02, -5.4219e+01, -4.0250e+01, -4.8625e+01, -3.5740e+03, + -1.1120e+04, -4.0320e+03, 5.7950e+02, -1.0281e+02, 3.8375e+02, + -3.4688e+01, -3.6938e+01, -7.8750e+01, -6.3219e+01, -5.6719e+01, + -7.8312e+01, -5.0375e+01, -3.8562e+01, -6.0938e+01, -7.9520e+03, + -3.5094e+01, -5.1844e+01, -8.9000e+01, 4.6375e+02, -9.8562e+01, + -4.4938e+01, -3.7875e+01, -1.0048e+04, -9.6800e+03, 5.4500e+02, + -5.9250e+01], + [-1.9531e+01, -2.1641e+01, 8.2938e+01, -2.9300e+03, -2.6380e+03, + -2.6260e+03, -2.2484e+01, 2.6150e+02, -5.5062e+01, -3.4500e+01, + 1.5700e+02, -2.6203e+01, -2.2547e+01, -3.2812e+01, -1.4250e+03, + -3.5140e+03, -1.4460e+03, 2.2712e+02, -6.0031e+01, 1.3062e+02, + -1.9031e+01, -1.9781e+01, -4.7781e+01, -3.8438e+01, -3.6656e+01, + -4.5500e+01, -3.0375e+01, -2.9234e+01, -4.0688e+01, -2.1320e+03, + -2.7500e+01, -3.9688e+01, -5.1750e+01, 1.6862e+02, -6.5125e+01, + -2.8312e+01, -2.2422e+01, -4.7320e+03, -3.7020e+03, 1.5562e+02, + -4.2312e+01], + [-7.5312e+01, -7.9500e+01, 3.5600e+02, -5.9560e+03, -5.2760e+03, + -6.2320e+03, -8.2688e+01, 3.0575e+02, -1.2262e+02, -9.6562e+01, + 2.9625e+02, -9.0312e+01, -8.3062e+01, -9.3812e+01, -2.3960e+03, + -6.4600e+03, -2.3760e+03, 4.4950e+02, -1.2619e+02, 2.3375e+02, + -7.5562e+01, -7.8812e+01, -1.1750e+02, -1.0356e+02, -1.0362e+02, + -1.1350e+02, -9.7562e+01, -8.7312e+01, -1.0488e+02, -5.4240e+03, + -8.6625e+01, -1.0125e+02, -1.1794e+02, 3.3025e+02, -1.3650e+02, + -9.0062e+01, -8.2062e+01, -6.4200e+03, -5.9880e+03, 2.4875e+02, + -1.1212e+02], + [-1.1055e+01, -4.2461e+00, 2.0600e+02, -6.5080e+03, -5.9560e+03, + -6.2920e+03, -4.5938e+00, 2.8675e+02, -4.8688e+01, -1.0781e+01, + 1.8475e+02, -1.5133e+01, -8.7109e+00, -9.8359e+00, -2.0620e+03, + -6.6280e+03, -2.6920e+03, 3.5325e+02, -4.6500e+01, 2.8250e+02, + -7.7695e+00, -8.3047e+00, -2.9719e+01, -1.7156e+01, -1.3102e+01, + -2.7438e+01, -7.4219e+00, -5.9805e+00, -1.4430e+01, -4.6000e+03, + -3.2930e+00, -5.2617e+00, -3.5469e+01, 3.4600e+02, -3.4281e+01, + -6.5273e+00, -7.6289e+00, -6.0880e+03, -6.3400e+03, 3.1900e+02, + -5.4180e+00]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([33, 39, 10, 2, 7, 17, 17, 19]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-4.0125e+01, -3.8219e+01, 4.0025e+02, -8.2720e+03, -7.5760e+03, + -8.5040e+03, -3.8281e+01, 4.9275e+02, -9.2625e+01, -5.3031e+01, + 4.4575e+02, -4.8438e+01, -3.9281e+01, -4.6875e+01, -3.0860e+03, + -8.3840e+03, -3.3620e+03, 3.9600e+02, -9.3562e+01, 1.4825e+02, + -3.4875e+01, -3.8281e+01, -7.4312e+01, -5.9969e+01, -5.6594e+01, + -7.1438e+01, -4.7094e+01, -4.4219e+01, -6.1875e+01, -5.8360e+03, + -4.0844e+01, -4.9062e+01, -8.2125e+01, 3.5775e+02, -9.3250e+01, + -4.6969e+01, -3.7844e+01, -8.4720e+03, -7.7080e+03, 4.2875e+02, + -6.0125e+01], + [-2.3688e+01, -2.1578e+01, 2.0250e+02, -3.9340e+03, -3.8960e+03, + -4.3880e+03, -2.2531e+01, 2.6575e+02, -6.1406e+01, -3.1594e+01, + 1.9975e+02, -2.5797e+01, -2.3781e+01, -3.0578e+01, -1.7210e+03, + -4.8640e+03, -1.8000e+03, 2.8475e+02, -6.0219e+01, 2.6575e+02, + -2.0719e+01, -2.2875e+01, -4.3875e+01, -3.4781e+01, -3.2656e+01, + -4.6844e+01, -2.6562e+01, -2.7859e+01, -3.7781e+01, -3.9660e+03, + -2.5797e+01, -3.2000e+01, -5.5500e+01, 9.0750e+01, -6.1656e+01, + -2.8516e+01, -2.3375e+01, -4.5320e+03, -4.5400e+03, 2.4612e+02, + -3.8406e+01], + [-6.6000e+01, -6.9125e+01, 5.1600e+02, -9.3440e+03, -8.0320e+03, + -9.1760e+03, -7.5062e+01, 5.2100e+02, -1.4800e+02, -9.5312e+01, + 4.9775e+02, -8.9188e+01, -7.6688e+01, -8.5938e+01, -3.3360e+03, + -9.5600e+03, -3.6440e+03, 5.2750e+02, -1.5538e+02, 2.6325e+02, + -6.6125e+01, -6.9812e+01, -1.2744e+02, -1.0469e+02, -1.0275e+02, + -1.2250e+02, -8.7562e+01, -7.9125e+01, -1.0675e+02, -7.2360e+03, + -7.7750e+01, -9.5438e+01, -1.3738e+02, 4.9225e+02, -1.6088e+02, + -8.5312e+01, -7.2750e+01, -1.0160e+04, -8.4480e+03, 4.3050e+02, + -1.0994e+02], + [-2.1969e+01, -2.5453e+01, 1.8975e+02, -2.6780e+03, -3.1460e+03, + -4.5000e+03, -2.5328e+01, 1.4475e+02, -4.3875e+01, -3.5469e+01, + 1.9000e+02, -2.8219e+01, -2.5422e+01, -3.1734e+01, -6.9250e+02, + -3.2200e+03, -1.3350e+03, 1.0619e+02, -5.4031e+01, 1.1238e+02, + -1.9781e+01, -2.2156e+01, -4.9125e+01, -3.8781e+01, -4.1062e+01, + -4.6812e+01, -3.0531e+01, -3.1328e+01, -4.1781e+01, -3.4520e+03, + -3.0094e+01, -3.5938e+01, -4.7219e+01, 1.0519e+02, -6.2438e+01, + -2.9047e+01, -2.3828e+01, -2.4040e+03, -3.7140e+03, 1.2962e+02, + -4.4625e+01], + [-2.7547e+01, -2.5203e+01, 3.3475e+02, -8.3440e+03, -8.0040e+03, + -9.2320e+03, -2.4391e+01, 3.4925e+02, -8.9438e+01, -3.9531e+01, + 5.4800e+02, -3.6562e+01, -3.0156e+01, -3.8469e+01, -2.9920e+03, + -8.7520e+03, -3.5900e+03, 3.5800e+02, -9.2562e+01, 2.9225e+02, + -2.3141e+01, -2.5609e+01, -6.5938e+01, -4.8969e+01, -4.5438e+01, + -6.7625e+01, -3.6750e+01, -3.0844e+01, -4.7625e+01, -8.5840e+03, + -2.7562e+01, -3.9875e+01, -7.8188e+01, 5.3000e+02, -8.8250e+01, + -3.1719e+01, -2.8594e+01, -8.0480e+03, -7.8920e+03, 4.0925e+02, + -5.0219e+01], + [ 3.8062e+01, 4.6312e+01, 5.8828e+00, -2.1360e+03, -2.4940e+03, + -2.1000e+03, 4.5312e+01, -1.3969e+01, 2.9844e+01, 4.4812e+01, + 1.3550e+02, 4.0469e+01, 4.1438e+01, 4.3062e+01, -7.0550e+02, + -2.1540e+03, -8.1400e+02, 2.3766e+01, 3.1391e+01, 1.4203e+01, + 4.0875e+01, 4.0688e+01, 4.1094e+01, 4.0688e+01, 4.5844e+01, + 3.6500e+01, 5.0250e+01, 4.6875e+01, 5.0156e+01, -2.4540e+03, + 4.9250e+01, 4.9500e+01, 3.5531e+01, 9.6625e+01, 4.4000e+01, + 4.5938e+01, 4.3094e+01, -1.5190e+03, -1.8650e+03, 1.3000e+02, + 4.9094e+01], + [ 3.7312e+01, 4.5281e+01, 1.2422e+01, -2.0900e+03, -2.4960e+03, + -2.1040e+03, 4.4594e+01, -5.2812e+00, 2.9062e+01, 4.3531e+01, + 1.4088e+02, 3.9750e+01, 4.0844e+01, 4.1781e+01, -7.1800e+02, + -2.1580e+03, -8.2250e+02, 1.2969e+01, 3.0312e+01, 9.2578e+00, + 4.0094e+01, 4.0094e+01, 3.9250e+01, 3.9000e+01, 4.4219e+01, + 3.5062e+01, 4.8969e+01, 4.5688e+01, 4.8594e+01, -2.4280e+03, + 4.8125e+01, 4.7812e+01, 3.4562e+01, 9.5438e+01, 4.1750e+01, + 4.4969e+01, 4.2031e+01, -1.5590e+03, -1.8280e+03, 1.3138e+02, + 4.7156e+01], + [-6.4375e+01, -6.7750e+01, 5.1150e+02, -9.2880e+03, -8.0080e+03, + -9.1120e+03, -7.3688e+01, 5.2900e+02, -1.4688e+02, -9.3938e+01, + 5.0000e+02, -8.7062e+01, -7.4938e+01, -8.4500e+01, -3.3160e+03, + -9.5040e+03, -3.6280e+03, 5.2050e+02, -1.5388e+02, 2.5488e+02, + -6.4625e+01, -6.8125e+01, -1.2531e+02, -1.0294e+02, -1.0125e+02, + -1.2094e+02, -8.5688e+01, -7.7750e+01, -1.0531e+02, -7.1640e+03, + -7.6500e+01, -9.3875e+01, -1.3625e+02, 4.8300e+02, -1.5875e+02, + -8.4188e+01, -7.1125e+01, -1.0120e+04, -8.4320e+03, 4.3200e+02, + -1.0812e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 7, 2, 39, 19, 33, 10, 17]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -83.6875, -81.5000, 795.5000, -15296.0000, -13216.0000, + -16312.0000, -88.8750, 764.0000, -190.0000, -114.0625, + 713.5000, -109.4375, -90.5625, -103.1250, -4940.0000, + -14792.0000, -5916.0000, 656.0000, -193.3750, 436.2500, + -79.4375, -82.3125, -151.5000, -125.9375, -122.2500, + -149.2500, -103.5000, -91.8750, -127.8125, -11200.0000, + -85.8125, -113.6875, -171.0000, 791.0000, -194.2500, + -98.6875, -86.5000, -15096.0000, -12928.0000, 845.5000, + -125.0625], + [ -56.3438, -53.3750, 637.0000, -12304.0000, -10704.0000, + -13224.0000, -57.0000, 536.0000, -137.0000, -78.0625, + 552.5000, -79.6875, -61.5000, -72.6250, -3966.0000, + -11664.0000, -4572.0000, 630.0000, -137.3750, 370.2500, + -53.8125, -56.0625, -111.0625, -90.0000, -84.0625, + -105.8750, -75.0000, -61.0000, -84.0625, -9016.0000, + -55.3750, -79.5000, -120.6875, 712.5000, -132.7500, + -65.0625, -59.1250, -12384.0000, -10208.0000, 654.0000, + -87.3125], + [ -43.1562, -47.5625, 306.0000, -2682.0000, -2830.0000, + -3002.0000, -50.2188, 164.3750, -73.4375, -59.4375, + 170.1250, -51.0312, -49.3750, -56.6562, -1461.0000, + -3178.0000, -1366.0000, 182.5000, -78.6875, 137.7500, + -44.4062, -45.3438, -73.8125, -62.6562, -63.6250, + -72.6250, -57.1875, -55.7188, -66.9375, -3490.0000, + -55.2812, -62.2812, -73.1250, 99.8125, -88.5625, + -55.6250, -48.1250, -3792.0000, -3212.0000, 91.5625, + -74.2500], + [ -41.7500, -44.7500, 358.0000, -6268.0000, -5392.0000, + -5528.0000, -48.4062, 302.7500, -93.9375, -64.0625, + 330.2500, -57.9688, -49.9688, -57.7188, -2002.0000, + -6712.0000, -2182.0000, 338.2500, -103.3750, 208.0000, + -41.7812, -46.3438, -82.5625, -69.6250, -70.5000, + -79.8125, -56.5000, -52.1562, -73.5625, -5000.0000, + -52.7188, -67.0625, -89.9375, 346.7500, -110.2500, + -56.0625, -47.9375, -7148.0000, -5304.0000, 228.2500, + -72.1875], + [ -82.5000, -80.9375, 845.5000, -12520.0000, -11320.0000, + -12680.0000, -88.9375, 779.0000, -188.2500, -116.0625, + 589.0000, -104.1250, -90.2500, -104.5625, -4788.0000, + -13368.0000, -5088.0000, 710.0000, -194.1250, 439.5000, + -77.8125, -82.3750, -156.1250, -126.9375, -122.8750, + -151.1250, -100.6250, -95.8125, -130.6250, -9880.0000, + -92.1250, -112.0000, -171.3750, 662.5000, -196.2500, + -103.8125, -87.6250, -14704.0000, -12336.0000, 586.5000, + -128.6250], + [ -53.9688, -53.6562, 282.5000, -5944.0000, -5612.0000, + -5948.0000, -55.0938, 458.5000, -103.9375, -69.7500, + 235.3750, -63.5000, -57.9688, -65.3125, -2192.0000, + -7512.0000, -2462.0000, 315.0000, -103.5000, 220.1250, + -52.3125, -53.5625, -86.5000, -73.9375, -71.1875, + -85.8750, -64.7500, -59.0938, -74.8125, -6000.0000, + -57.1875, -70.6875, -96.8750, 406.7500, -107.8750, + -63.6250, -55.2812, -6960.0000, -7088.0000, 351.7500, + -75.8750], + [ -42.9688, -46.6562, 435.7500, -5400.0000, -4272.0000, + -5892.0000, -51.2500, 186.5000, -87.3750, -62.6562, + 302.0000, -65.5000, -52.9375, -56.2188, -1860.0000, + -4740.0000, -1960.0000, 278.0000, -89.9375, 139.6250, + -46.3438, -50.0938, -77.3750, -67.3125, -67.5625, + -71.7500, -56.8750, -50.6875, -68.7500, -3174.0000, + -52.5000, -64.6875, -80.2500, 308.0000, -96.0625, + -55.2812, -49.5625, -5436.0000, -3374.0000, 256.2500, + -69.0000], + [ -49.0625, -45.5312, 481.7500, -11184.0000, -10256.0000, + -11800.0000, -46.6250, 548.5000, -112.6875, -60.6875, + 538.5000, -61.3438, -49.0938, -58.8750, -3734.0000, + -11304.0000, -4352.0000, 548.5000, -107.1875, 438.2500, + -44.5625, -46.2812, -87.0000, -72.0000, -65.4375, + -85.3125, -56.5938, -50.0000, -69.0000, -8172.0000, + -43.9062, -61.2188, -96.3750, 567.5000, -103.3750, + -52.9688, -49.5000, -10800.0000, -9984.0000, 643.0000, + -69.2500]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 39, 33, 7, 17, 2, 19, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-2.7906e+01, -2.5453e+01, 3.2300e+02, -6.2720e+03, -5.4400e+03, + -5.4680e+03, -2.1016e+01, 3.3775e+02, -6.9000e+01, -3.7844e+01, + 2.2612e+02, -2.9219e+01, -2.2438e+01, -3.9906e+01, -2.0680e+03, + -6.5920e+03, -2.2600e+03, 2.5825e+02, -7.2938e+01, 2.7375e+02, + -2.0859e+01, -2.1172e+01, -5.9781e+01, -4.5344e+01, -4.1375e+01, + -5.6969e+01, -3.8250e+01, -3.2219e+01, -4.4500e+01, -5.7520e+03, + -3.0266e+01, -4.3281e+01, -6.2875e+01, 3.7375e+02, -7.4375e+01, + -3.2094e+01, -2.5562e+01, -6.5760e+03, -5.5600e+03, 2.7250e+02, + -5.1156e+01], + [-4.4938e+01, -4.4406e+01, 4.6300e+02, -7.7400e+03, -6.9120e+03, + -8.0560e+03, -4.6531e+01, 3.8175e+02, -1.0356e+02, -6.2062e+01, + 4.4275e+02, -6.0688e+01, -4.8688e+01, -5.5781e+01, -2.9380e+03, + -8.0320e+03, -3.2340e+03, 4.7025e+02, -1.0394e+02, 1.6900e+02, + -4.3000e+01, -4.6156e+01, -8.4812e+01, -6.9375e+01, -6.6000e+01, + -8.0562e+01, -5.6969e+01, -5.0406e+01, -6.9000e+01, -5.4960e+03, + -4.8531e+01, -5.9625e+01, -9.1438e+01, 3.2625e+02, -1.0475e+02, + -5.4344e+01, -4.6562e+01, -8.5120e+03, -7.1360e+03, 4.3125e+02, + -7.1500e+01], + [ 3.1766e+01, 3.8719e+01, -9.2750e+01, -4.2850e+02, -1.1450e+03, + -3.3300e+02, 4.0969e+01, 2.1125e+01, 3.9625e+01, 4.8625e+01, + -1.5012e+02, 3.8094e+01, 3.7406e+01, 4.2906e+01, -2.5538e+02, + -1.2260e+03, -4.2450e+02, -7.0625e+01, 5.1875e+01, 1.0319e+02, + 3.3500e+01, 3.5938e+01, 5.0375e+01, 4.6188e+01, 5.1594e+01, + 4.6281e+01, 4.6000e+01, 4.6656e+01, 5.5844e+01, -1.6170e+03, + 4.8156e+01, 5.2688e+01, 4.7094e+01, 1.3398e+01, 6.4812e+01, + 4.5094e+01, 3.7312e+01, 1.6775e+02, -8.7050e+02, 1.1669e+02, + 5.9219e+01], + [ 3.1984e+01, 3.9031e+01, -8.4688e+01, -6.0950e+02, -1.2430e+03, + -4.4475e+02, 4.1281e+01, 2.8703e+01, 3.9188e+01, 4.8562e+01, + -1.5175e+02, 3.8125e+01, 3.7656e+01, 4.2750e+01, -3.2075e+02, + -1.3390e+03, -4.7350e+02, -5.9906e+01, 5.1219e+01, 1.1588e+02, + 3.3781e+01, 3.6125e+01, 4.9344e+01, 4.5656e+01, 5.1094e+01, + 4.5469e+01, 4.6031e+01, 4.6531e+01, 5.5406e+01, -1.6970e+03, + 4.8188e+01, 5.1812e+01, 4.6781e+01, 2.1328e+01, 6.3906e+01, + 4.4938e+01, 3.7344e+01, -6.1328e+00, -1.0000e+03, 1.1825e+02, + 5.8438e+01], + [-5.1250e+01, -4.5969e+01, 5.6300e+02, -1.2064e+04, -1.0856e+04, + -1.2240e+04, -5.2531e+01, 5.6050e+02, -1.3150e+02, -7.1062e+01, + 5.9200e+02, -6.9438e+01, -5.5406e+01, -6.3031e+01, -4.0800e+03, + -1.1840e+04, -4.6240e+03, 5.4850e+02, -1.2838e+02, 4.5975e+02, + -4.9062e+01, -5.1156e+01, -1.0056e+02, -8.0750e+01, -7.5500e+01, + -1.0019e+02, -6.1000e+01, -5.3844e+01, -8.0688e+01, -8.7360e+03, + -4.8938e+01, -6.5812e+01, -1.1306e+02, 3.9900e+02, -1.2212e+02, + -6.0250e+01, -5.2906e+01, -1.1504e+04, -1.0872e+04, 6.6600e+02, + -7.6312e+01], + [-4.4000e+01, -4.3438e+01, 4.2025e+02, -6.7080e+03, -5.8360e+03, + -7.7800e+03, -4.4656e+01, 3.6600e+02, -1.0281e+02, -5.9844e+01, + 3.6125e+02, -5.3719e+01, -4.4812e+01, -5.4312e+01, -2.2740e+03, + -6.9720e+03, -2.7180e+03, 3.4350e+02, -1.0488e+02, 1.4050e+02, + -4.0344e+01, -4.3031e+01, -7.9938e+01, -6.5438e+01, -6.1250e+01, + -7.6500e+01, -5.2719e+01, -4.8719e+01, -6.6438e+01, -5.3960e+03, + -4.7250e+01, -5.7250e+01, -9.1625e+01, 3.9625e+02, -1.0038e+02, + -5.3500e+01, -4.4406e+01, -7.0120e+03, -6.0360e+03, 3.9900e+02, + -6.4875e+01], + [-3.0125e+01, -2.7953e+01, 3.3775e+02, -6.3240e+03, -5.4480e+03, + -5.4920e+03, -2.3219e+01, 3.4900e+02, -7.2375e+01, -4.0688e+01, + 2.3138e+02, -3.1078e+01, -2.4172e+01, -4.2812e+01, -2.0660e+03, + -6.6000e+03, -2.2540e+03, 2.5975e+02, -7.6688e+01, 2.7675e+02, + -2.3016e+01, -2.2891e+01, -6.3094e+01, -4.8250e+01, -4.4344e+01, + -6.0375e+01, -4.1250e+01, -3.4875e+01, -4.7469e+01, -5.7880e+03, + -3.3125e+01, -4.6594e+01, -6.6312e+01, 3.7500e+02, -7.8750e+01, + -3.4719e+01, -2.7641e+01, -6.6520e+03, -5.5480e+03, 2.6375e+02, + -5.4844e+01], + [-2.4219e+01, -2.1938e+01, 1.1694e+02, -5.2600e+03, -5.2520e+03, + -5.1920e+03, -2.4094e+01, 2.7250e+02, -6.7062e+01, -3.4250e+01, + 2.4775e+02, -3.2250e+01, -2.6484e+01, -2.8156e+01, -2.1180e+03, + -5.7800e+03, -2.2120e+03, 3.0375e+02, -6.3594e+01, 2.7850e+02, + -2.2172e+01, -2.3266e+01, -4.5906e+01, -3.7562e+01, -3.3844e+01, + -4.6438e+01, -2.5219e+01, -2.4656e+01, -3.4594e+01, -5.5800e+03, + -2.4625e+01, -2.9406e+01, -5.5781e+01, 3.3975e+02, -5.8656e+01, + -2.9141e+01, -2.5250e+01, -5.4120e+03, -5.1720e+03, 2.8025e+02, + -3.0703e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([ 2, 33, 19, 39, 17, 17, 7, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-3.2844e+01, -2.8797e+01, 2.5825e+02, -8.8400e+03, -8.2000e+03, + -8.7120e+03, -3.2094e+01, 3.3500e+02, -9.2875e+01, -4.6500e+01, + 4.6175e+02, -4.7594e+01, -3.5750e+01, -4.4688e+01, -3.1140e+03, + -8.3920e+03, -3.5360e+03, 4.5075e+02, -8.9688e+01, 3.6750e+02, + -3.2250e+01, -3.1984e+01, -7.0000e+01, -5.5656e+01, -4.9938e+01, + -7.0812e+01, -4.1531e+01, -3.4938e+01, -4.9844e+01, -7.8280e+03, + -2.9531e+01, -4.5438e+01, -7.9000e+01, 4.5475e+02, -8.2938e+01, + -3.6812e+01, -3.5125e+01, -8.6960e+03, -8.2240e+03, 4.5475e+02, + -5.1688e+01], + [-4.3281e+01, -4.0094e+01, 3.2750e+02, -8.3440e+03, -7.7440e+03, + -7.4920e+03, -4.3656e+01, 3.6375e+02, -1.0519e+02, -5.7406e+01, + 4.7650e+02, -5.7781e+01, -4.7156e+01, -5.3750e+01, -3.1740e+03, + -7.8160e+03, -3.5640e+03, 4.9225e+02, -9.9938e+01, 3.9925e+02, + -4.3781e+01, -4.4219e+01, -7.5875e+01, -6.3219e+01, -5.8875e+01, + -7.7875e+01, -5.0562e+01, -4.4625e+01, -6.1625e+01, -8.0440e+03, + -4.1250e+01, -5.1312e+01, -8.9188e+01, 4.4575e+02, -9.2688e+01, + -5.1188e+01, -4.5656e+01, -8.6880e+03, -8.3440e+03, 3.7725e+02, + -6.0000e+01], + [-9.4000e+01, -9.6125e+01, 7.7200e+02, -1.2960e+04, -1.1512e+04, + -1.4648e+04, -1.0394e+02, 6.1450e+02, -2.1238e+02, -1.3488e+02, + 6.3600e+02, -1.1794e+02, -1.0181e+02, -1.2519e+02, -4.6440e+03, + -1.3192e+04, -5.1280e+03, 9.3000e+02, -2.2038e+02, 5.1900e+02, + -8.9250e+01, -9.4750e+01, -1.7662e+02, -1.4375e+02, -1.4138e+02, + -1.7225e+02, -1.2300e+02, -1.1350e+02, -1.5412e+02, -1.1272e+04, + -1.1169e+02, -1.3375e+02, -1.9712e+02, 6.0750e+02, -2.2762e+02, + -1.1925e+02, -9.9312e+01, -1.3016e+04, -1.2104e+04, 5.9650e+02, + -1.5762e+02], + [ 8.5156e+00, 1.3859e+01, 1.6388e+02, -2.2040e+03, -2.3140e+03, + -3.0980e+03, 1.0484e+01, 7.9625e+01, -9.2500e+00, 1.1148e+01, + 6.9875e+01, 2.8828e+00, 7.7695e+00, 1.1773e+01, -1.0400e+03, + -2.7060e+03, -1.0760e+03, 1.3488e+02, -2.1406e+00, 2.8350e+02, + 9.5547e+00, 7.9219e+00, 6.8242e+00, 9.9766e+00, 1.2898e+01, + 6.5352e+00, 1.7688e+01, 1.4664e+01, 9.6719e+00, -1.6260e+03, + 1.5125e+01, 2.0031e+01, 3.5620e-01, 6.2125e+01, 6.2344e+00, + 1.1516e+01, 1.1430e+01, -2.3920e+03, -2.1580e+03, 1.5150e+02, + 1.6484e+01], + [-4.3188e+01, -4.7844e+01, 2.7125e+02, -2.9440e+03, -2.2440e+03, + -3.3160e+03, -4.9125e+01, 1.6750e+02, -8.5688e+01, -6.6000e+01, + 2.8175e+02, -5.4781e+01, -4.8656e+01, -5.8719e+01, -1.1810e+03, + -2.9340e+03, -1.3840e+03, 2.4750e+02, -9.8438e+01, 8.1250e+01, + -4.2875e+01, -4.5375e+01, -8.5938e+01, -6.8750e+01, -6.8938e+01, + -7.7375e+01, -6.2781e+01, -5.8375e+01, -7.2562e+01, -2.4000e+03, + -5.7094e+01, -6.9062e+01, -8.4812e+01, 2.3375e+02, -1.0581e+02, + -5.6750e+01, -4.9844e+01, -3.6300e+03, -3.2840e+03, 4.7125e+01, + -7.5375e+01], + [-3.3812e+01, -3.4625e+01, 1.3488e+02, -1.8000e+03, -1.6200e+03, + -1.7050e+03, -3.4906e+01, 1.8312e+02, -6.0625e+01, -4.0781e+01, + 1.0688e+02, -3.8562e+01, -3.5906e+01, -3.9344e+01, -7.4400e+02, + -2.3780e+03, -6.6450e+02, 8.0000e+01, -5.4500e+01, 6.2156e+01, + -3.4219e+01, -3.6375e+01, -4.3656e+01, -4.0438e+01, -3.7906e+01, + -4.4156e+01, -3.8562e+01, -3.4438e+01, -3.9469e+01, -1.9910e+03, + -3.5969e+01, -3.8625e+01, -5.2844e+01, 1.3225e+02, -5.2406e+01, + -3.7938e+01, -3.5594e+01, -2.0010e+03, -1.8300e+03, 2.7578e+01, + -3.8688e+01], + [-3.4469e+01, -3.5375e+01, 1.3462e+02, -1.8770e+03, -1.6530e+03, + -1.8360e+03, -3.5250e+01, 1.8188e+02, -6.1844e+01, -4.1531e+01, + 1.1331e+02, -3.8719e+01, -3.6188e+01, -4.0094e+01, -7.6400e+02, + -2.4140e+03, -6.9750e+02, 7.9188e+01, -5.5875e+01, 6.0875e+01, + -3.4656e+01, -3.6844e+01, -4.5156e+01, -4.1531e+01, -3.8875e+01, + -4.5438e+01, -3.9375e+01, -3.5469e+01, -4.0656e+01, -1.9870e+03, + -3.6938e+01, -3.9688e+01, -5.4188e+01, 1.3138e+02, -5.4312e+01, + -3.8781e+01, -3.6156e+01, -2.1060e+03, -1.8390e+03, 3.6969e+01, + -3.9969e+01], + [-3.7625e+01, -3.6906e+01, 4.0125e+02, -6.8120e+03, -6.0440e+03, + -7.0960e+03, -4.1281e+01, 3.9325e+02, -8.8938e+01, -5.4250e+01, + 3.5900e+02, -5.1094e+01, -4.3031e+01, -4.7781e+01, -2.2540e+03, + -6.8960e+03, -2.6600e+03, 3.3325e+02, -8.9375e+01, 2.3138e+02, + -3.7562e+01, -3.8125e+01, -6.8875e+01, -5.7375e+01, -5.6875e+01, + -6.8375e+01, -4.4094e+01, -4.3125e+01, -6.0562e+01, -5.7600e+03, + -4.1562e+01, -5.0375e+01, -8.0688e+01, 3.6850e+02, -8.9062e+01, + -4.7781e+01, -3.8312e+01, -7.3600e+03, -6.2720e+03, 3.1200e+02, + -5.8375e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([19, 10, 2, 17, 17, 39, 33, 7]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-2.7188e+01, -2.3000e+01, 3.8350e+02, -8.3360e+03, -7.6600e+03, + -7.6160e+03, -2.5016e+01, 4.7825e+02, -7.1000e+01, -3.7156e+01, + 3.1275e+02, -3.8250e+01, -2.9219e+01, -3.4875e+01, -3.0060e+03, + -8.7040e+03, -3.1820e+03, 4.8400e+02, -6.8375e+01, 3.9100e+02, + -2.4922e+01, -2.6734e+01, -5.1750e+01, -4.3125e+01, -3.9469e+01, + -5.3219e+01, -3.4344e+01, -2.6562e+01, -4.3969e+01, -6.7760e+03, + -2.2875e+01, -3.6188e+01, -6.0344e+01, 3.0425e+02, -6.6500e+01, + -3.0422e+01, -2.6078e+01, -8.2800e+03, -7.7320e+03, 3.7875e+02, + -4.2312e+01], + + 0%| | 0/140 [00:29) tensor([ 2, 19, 33, 17, 39, 17, 7, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-7.1812e+01, -7.6062e+01, 3.8500e+02, -6.8320e+03, -6.0880e+03, + -6.5200e+03, -7.9500e+01, 4.1950e+02, -1.2712e+02, -9.4812e+01, + 3.5600e+02, -8.8938e+01, -8.1250e+01, -9.1000e+01, -2.3080e+03, + -6.8760e+03, -2.7540e+03, 3.1025e+02, -1.3262e+02, 3.6475e+02, + -7.4000e+01, -7.5688e+01, -1.1800e+02, -1.0212e+02, -1.0038e+02, + -1.1412e+02, -9.1812e+01, -8.3625e+01, -1.0462e+02, -5.7200e+03, + -8.1625e+01, -1.0194e+02, -1.2075e+02, 4.1425e+02, -1.4012e+02, + -8.7375e+01, -7.9062e+01, -9.0640e+03, -6.9840e+03, 2.1488e+02, + -1.0694e+02], + [-9.5938e+00, -1.1547e+01, -1.9812e+01, -1.2450e+03, -1.6070e+03, + -2.9120e+03, -1.0812e+01, 1.0562e+02, -1.8906e+01, -1.5047e+01, + 1.0675e+02, -9.1875e+00, -1.0742e+01, -1.0562e+01, -3.4600e+02, + -1.5770e+03, -5.4250e+02, -3.9805e+00, -2.3953e+01, 1.8300e+02, + -9.1172e+00, -1.2008e+01, -1.9453e+01, -1.4695e+01, -1.5680e+01, + -1.6375e+01, -6.8867e+00, -1.3703e+01, -1.8469e+01, -2.2200e+03, + -1.5094e+01, -1.3945e+01, -1.9375e+01, 1.5800e+02, -2.4281e+01, + -1.4305e+01, -9.9922e+00, -2.1980e+03, -1.6120e+03, 7.0688e+01, + -1.4055e+01], + [-1.7969e+01, -1.4141e+01, 2.3375e+02, -4.5080e+03, -4.9640e+03, + -5.5120e+03, -1.5312e+01, 3.4325e+02, -5.7438e+01, -2.1859e+01, + 3.2100e+02, -1.9469e+01, -1.6359e+01, -1.9703e+01, -1.5360e+03, + -5.6480e+03, -1.9750e+03, 1.3950e+02, -5.2750e+01, 2.1612e+02, + -1.5500e+01, -1.5805e+01, -3.4156e+01, -2.7391e+01, -1.9859e+01, + -3.4906e+01, -1.3297e+01, -1.3625e+01, -1.9453e+01, -4.1200e+03, + -1.2047e+01, -1.9016e+01, -4.6969e+01, 2.1300e+02, -3.8375e+01, + -1.7078e+01, -1.7172e+01, -6.6560e+03, -5.1560e+03, 2.4712e+02, + -1.5352e+01], + [-5.5562e+01, -5.6469e+01, 4.6725e+02, -8.2160e+03, -7.4880e+03, + -7.5440e+03, -5.8781e+01, 4.8300e+02, -1.1744e+02, -7.4750e+01, + 4.1500e+02, -6.4750e+01, -5.7906e+01, -7.0688e+01, -2.6780e+03, + -8.4560e+03, -3.0180e+03, 3.9650e+02, -1.2062e+02, 3.8950e+02, + -5.2375e+01, -5.3375e+01, -9.8250e+01, -7.9750e+01, -7.8438e+01, + -9.7625e+01, -7.1250e+01, -6.3719e+01, -8.5750e+01, -7.6280e+03, + -6.2906e+01, -7.6375e+01, -1.0844e+02, 4.1000e+02, -1.2312e+02, + -6.7812e+01, -5.7969e+01, -9.7360e+03, -8.3760e+03, 2.8850e+02, + -8.5500e+01], + [-1.2138e+02, -1.3000e+02, 8.0000e+02, -1.1824e+04, -1.0208e+04, + -1.3360e+04, -1.3550e+02, 6.0300e+02, -2.2425e+02, -1.6200e+02, + 7.2500e+02, -1.4688e+02, -1.3250e+02, -1.5388e+02, -3.8620e+03, + -1.1736e+04, -4.6640e+03, 7.8900e+02, -2.3462e+02, 5.0375e+02, + -1.1856e+02, -1.2444e+02, -2.0362e+02, -1.7212e+02, -1.7325e+02, + -1.9438e+02, -1.5612e+02, -1.4538e+02, -1.8562e+02, -9.9440e+03, + -1.4525e+02, -1.6900e+02, -2.1238e+02, 5.8100e+02, -2.4988e+02, + -1.5112e+02, -1.3100e+02, -1.2968e+04, -1.0800e+04, 4.6875e+02, + -1.8988e+02], + [-3.9500e+01, -3.8438e+01, 3.5950e+02, -7.0000e+03, -6.5880e+03, + -5.8720e+03, -3.9656e+01, 4.3875e+02, -8.9562e+01, -5.2438e+01, + 3.2175e+02, -4.4844e+01, -4.0000e+01, -5.0312e+01, -2.2960e+03, + -7.3560e+03, -2.5260e+03, 2.9675e+02, -9.0750e+01, 3.4725e+02, + -3.6094e+01, -3.6406e+01, -7.1062e+01, -5.6406e+01, -5.4375e+01, + -7.2562e+01, -5.0438e+01, -4.3219e+01, -5.9719e+01, -6.8840e+03, + -4.1938e+01, -5.3625e+01, -8.1625e+01, 3.5075e+02, -8.9938e+01, + -4.6938e+01, -3.9906e+01, -8.5120e+03, -7.5440e+03, 2.3812e+02, + -5.9250e+01], + [-1.3450e+02, -1.4388e+02, 8.9750e+02, -1.1840e+04, -1.0192e+04, + -1.3568e+04, -1.5262e+02, 5.3700e+02, -2.3938e+02, -1.8275e+02, + 8.4700e+02, -1.5888e+02, -1.4575e+02, -1.7238e+02, -3.9580e+03, + -1.1616e+04, -4.7200e+03, 8.3000e+02, -2.5650e+02, 5.9150e+02, + -1.3100e+02, -1.3875e+02, -2.2800e+02, -1.9125e+02, -1.9538e+02, + -2.1700e+02, -1.7275e+02, -1.6725e+02, -2.1075e+02, -9.4960e+03, + -1.6462e+02, -1.9000e+02, -2.3162e+02, 5.4000e+02, -2.7975e+02, + -1.6788e+02, -1.4725e+02, -1.2392e+04, -1.1344e+04, 3.4075e+02, + -2.1650e+02], + [-4.3125e+01, -4.2938e+01, 4.4075e+02, -7.6840e+03, -7.0880e+03, + -9.3360e+03, -4.6062e+01, 4.8375e+02, -1.2375e+02, -6.5312e+01, + 4.4500e+02, -5.7031e+01, -4.6781e+01, -5.8688e+01, -2.6960e+03, + -8.1040e+03, -3.3480e+03, 4.5425e+02, -1.2606e+02, 2.4525e+02, + -4.1375e+01, -4.2875e+01, -9.2250e+01, -7.2312e+01, -6.6938e+01, + -9.0562e+01, -5.3688e+01, -5.0500e+01, -7.2125e+01, -6.3000e+03, + -4.9625e+01, -6.2000e+01, -1.1019e+02, 3.8675e+02, -1.2100e+02, + -5.5656e+01, -4.5531e+01, -8.9280e+03, -7.7400e+03, 4.2100e+02, + -7.1562e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([39, 17, 2, 17, 19, 10, 33, 7]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -80.7500, -87.1875, 534.5000, -9328.0000, -8248.0000, + -10032.0000, -91.2500, 398.2500, -158.1250, -114.2500, + 600.5000, -103.8125, -91.4375, -104.5000, -3482.0000, + -9552.0000, -3780.0000, 523.5000, -166.1250, 336.2500, + -82.3125, -85.3125, -140.2500, -122.8125, -123.3750, + -136.2500, -105.3750, -98.3125, -127.9375, -8144.0000, + -97.5000, -116.8125, -149.2500, 649.5000, -175.7500, + -103.3125, -89.5000, -10392.0000, -8696.0000, 419.2500, + -130.6250], + [ -87.7500, -93.5000, 462.5000, -10720.0000, -9064.0000, + -10968.0000, -91.1250, 500.2500, -170.7500, -121.6250, + 577.5000, -101.8750, -93.1875, -118.5625, -3374.0000, + -10592.0000, -4156.0000, 567.0000, -184.1250, 552.0000, + -85.0625, -88.0000, -162.1250, -133.7500, -133.2500, + -153.8750, -117.5625, -109.6875, -136.5000, -9504.0000, + -106.6250, -132.7500, -162.0000, 698.0000, -198.0000, + -108.4375, -96.7500, -11496.0000, -9488.0000, 404.2500, + -150.0000], + [ -82.6875, -85.5625, 654.0000, -10168.0000, -9704.0000, + -11640.0000, -93.8125, 419.0000, -175.8750, -118.0000, + 694.0000, -109.4375, -92.0000, -110.3125, -3738.0000, + -11048.0000, -4420.0000, 521.5000, -184.0000, 462.0000, + -82.4375, -84.0000, -156.3750, -130.3750, -128.3750, + -151.6250, -111.3750, -99.3750, -133.5000, -8936.0000, + -98.7500, -121.3125, -165.0000, 563.0000, -194.3750, + -103.7500, -92.6875, -11392.0000, -10344.0000, 395.5000, + -138.2500], + [ -112.2500, -121.0625, 736.0000, -10136.0000, -8832.0000, + -12032.0000, -124.1250, 528.0000, -211.6250, -154.1250, + 683.0000, -133.8750, -120.6875, -146.2500, -3162.0000, + -10232.0000, -4164.0000, 583.5000, -225.6250, 436.0000, + -109.6875, -113.2500, -197.5000, -163.6250, -164.2500, + -186.6250, -145.5000, -139.3750, -175.5000, -8960.0000, + -137.6250, -163.5000, -202.2500, 619.5000, -241.1250, + -141.3750, -122.6250, -12840.0000, -10200.0000, 397.5000, + -183.7500], + [ -51.6250, -54.5938, 530.0000, -8040.0000, -7152.0000, + -8840.0000, -59.9688, 306.7500, -119.7500, -76.3750, + 523.0000, -70.3750, -59.7812, -68.0000, -2650.0000, + -7968.0000, -3332.0000, 491.7500, -124.9375, 382.2500, + -53.3750, -56.3438, -98.8750, -82.2500, -81.8125, + -93.8125, -63.7500, -62.8438, -86.0625, -6932.0000, + -61.4688, -71.1250, -107.4375, 511.5000, -124.8125, + -68.3125, -57.5000, -8864.0000, -7456.0000, 337.0000, + -81.7500], + [ -81.1250, -87.1250, 525.0000, -9576.0000, -8368.0000, + -10168.0000, -90.0625, 415.2500, -158.5000, -114.4375, + 588.5000, -101.8125, -90.7500, -105.6250, -3448.0000, + -9704.0000, -3820.0000, 537.0000, -167.6250, 373.5000, + -81.6250, -84.5000, -142.6250, -123.0000, -123.5000, + -138.0000, -105.9375, -99.3750, -128.3750, -8400.0000, + -98.1250, -118.0625, -150.2500, 655.0000, -178.0000, + -103.0000, -89.3750, -10536.0000, -8816.0000, 412.2500, + -132.7500], + [ -49.2500, -52.0938, 413.7500, -6696.0000, -5936.0000, + -7624.0000, -54.6875, 442.7500, -106.3125, -69.1250, + 350.0000, -63.7500, -56.5000, -64.2500, -2400.0000, + -6992.0000, -2744.0000, 409.7500, -106.5625, 295.2500, + -49.6562, -50.7188, -87.7500, -74.8750, -72.8125, + -84.9375, -62.2500, -57.4688, -76.8125, -5424.0000, + -56.5938, -71.2500, -96.6875, 368.7500, -109.5000, + -61.9375, -52.5938, -8352.0000, -6336.0000, 333.2500, + -79.3125], + [ -49.1875, -52.0938, 419.5000, -6700.0000, -5964.0000, + -7776.0000, -55.0312, 442.0000, -107.3125, -69.6875, + 351.0000, -64.2500, -56.5938, -64.2500, -2418.0000, + -6960.0000, -2772.0000, 414.5000, -108.0625, 296.2500, + -49.6250, -50.8438, -88.4375, -75.2500, -73.3125, + -85.6250, -62.2500, -57.7500, -77.5625, -5372.0000, + -56.9688, -71.3750, -97.8750, 372.7500, -110.6875, + -62.1875, -52.6562, -8264.0000, -6308.0000, 333.5000, + -79.8125]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([10, 2, 17, 33, 17, 19, 7, 39]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-7.1125e+01, -7.3750e+01, 4.8050e+02, -9.3600e+03, -8.2400e+03, + -1.0016e+04, -8.0688e+01, 3.7250e+02, -1.4712e+02, -9.7750e+01, + 6.5050e+02, -9.0750e+01, -7.8375e+01, -8.9688e+01, -2.7880e+03, + -8.7040e+03, -3.5620e+03, 5.1125e+02, -1.4988e+02, 4.4275e+02, + -7.1375e+01, -7.4750e+01, -1.2412e+02, -1.0356e+02, -1.0294e+02, + -1.2019e+02, -9.0250e+01, -8.2875e+01, -1.0962e+02, -7.4800e+03, + -8.1250e+01, -9.5875e+01, -1.3450e+02, 4.6575e+02, -1.5025e+02, + -8.7375e+01, -7.8500e+01, -9.4400e+03, -8.1720e+03, 4.1625e+02, + -1.0706e+02], + [-7.4125e+01, -7.7125e+01, 4.9325e+02, -9.5040e+03, -8.3440e+03, + -1.0168e+04, -8.4250e+01, 3.7750e+02, -1.5225e+02, -1.0169e+02, + 6.7300e+02, -9.4625e+01, -8.1938e+01, -9.3375e+01, -2.7960e+03, + -8.7680e+03, -3.6020e+03, 5.1250e+02, -1.5525e+02, 4.4450e+02, + -7.4250e+01, -7.8000e+01, -1.2925e+02, -1.0738e+02, -1.0719e+02, + -1.2500e+02, -9.3188e+01, -8.6688e+01, -1.1419e+02, -7.5040e+03, + -8.5000e+01, -9.9500e+01, -1.3925e+02, 4.7825e+02, -1.5588e+02, + -9.1000e+01, -8.1750e+01, -9.6880e+03, -8.2720e+03, 4.1200e+02, + -1.1200e+02], + [-5.1344e+01, -5.6062e+01, 3.5975e+02, -2.7660e+03, -2.3700e+03, + -4.4840e+03, -6.2031e+01, 1.5025e+02, -1.0181e+02, -7.3188e+01, + 1.7538e+02, -6.6000e+01, -5.6781e+01, -6.7000e+01, -6.4500e+02, + -2.5540e+03, -1.3030e+03, 3.1900e+02, -1.1025e+02, 6.7500e+01, + -5.0875e+01, -5.3219e+01, -9.5562e+01, -7.6500e+01, -7.7125e+01, + -8.8750e+01, -6.8875e+01, -6.5812e+01, -8.1000e+01, -2.0500e+03, + -6.4750e+01, -7.7562e+01, -9.8875e+01, 1.8075e+02, -1.1831e+02, + -6.5000e+01, -5.8375e+01, -4.6160e+03, -3.0440e+03, 3.4438e+01, + -8.6500e+01], + [-8.3250e+01, -8.9000e+01, 5.4500e+02, -7.7560e+03, -6.8200e+03, + -8.7840e+03, -9.3688e+01, 2.5225e+02, -1.5575e+02, -1.1281e+02, + 5.5150e+02, -1.0019e+02, -9.2188e+01, -1.0644e+02, -2.5300e+03, + -7.6880e+03, -2.9420e+03, 5.4400e+02, -1.6512e+02, 3.5125e+02, + -8.2500e+01, -8.6688e+01, -1.3988e+02, -1.1969e+02, -1.1981e+02, + -1.3588e+02, -1.0719e+02, -9.9875e+01, -1.2469e+02, -7.4320e+03, + -1.0006e+02, -1.1738e+02, -1.4862e+02, 5.0225e+02, -1.7500e+02, + -1.0306e+02, -9.2188e+01, -9.2800e+03, -7.6960e+03, 2.9350e+02, + -1.2900e+02], + [ 4.3320e+00, 7.7773e+00, 1.7788e+02, -3.8920e+03, -4.4400e+03, + -4.9480e+03, 4.6289e+00, 1.4988e+02, -1.8375e+01, -2.7368e-01, + 2.1012e+02, 9.5557e-01, 2.9375e+00, 3.0527e+00, -1.3870e+03, + -4.1320e+03, -1.8120e+03, 1.1712e+02, -1.6969e+01, 2.2300e+02, + 4.7500e+00, 5.6367e+00, -9.1719e+00, -1.5635e+00, -2.3560e-01, + -1.0641e+01, 9.7109e+00, 4.3750e+00, -1.6377e+00, -3.9120e+03, + 5.7969e+00, 8.2500e+00, -1.2008e+01, 1.3225e+02, -9.0703e+00, + 3.2559e+00, 4.7891e+00, -4.2760e+03, -4.1760e+03, 2.3488e+02, + 1.3926e+00], + [-5.6938e+01, -5.9938e+01, 2.4650e+02, -7.5360e+03, -6.3560e+03, + -6.9440e+03, -6.5000e+01, 2.6650e+02, -1.0694e+02, -7.8938e+01, + 5.0700e+02, -7.1688e+01, -6.5000e+01, -7.0250e+01, -2.6260e+03, + -6.8040e+03, -2.8920e+03, 4.0375e+02, -1.0931e+02, 4.7250e+02, + -6.0469e+01, -6.0812e+01, -9.2562e+01, -8.1875e+01, -8.3875e+01, + -9.1750e+01, -7.0875e+01, -6.6562e+01, -8.9938e+01, -6.6600e+03, + -6.6125e+01, -7.5375e+01, -9.9188e+01, 3.8425e+02, -1.1525e+02, + -7.3688e+01, -6.2750e+01, -7.7480e+03, -7.0680e+03, 3.5000e+02, + -8.2875e+01], + [-5.5906e+01, -5.8688e+01, 2.4225e+02, -7.5200e+03, -6.3240e+03, + -6.8960e+03, -6.3000e+01, 2.6550e+02, -1.0481e+02, -7.7125e+01, + 4.9700e+02, -7.0188e+01, -6.3562e+01, -6.9188e+01, -2.6420e+03, + -6.7600e+03, -2.8880e+03, 4.0000e+02, -1.0694e+02, 4.7350e+02, + -5.9219e+01, -5.9625e+01, -9.1312e+01, -8.0562e+01, -8.2312e+01, + -9.0438e+01, -7.0000e+01, -6.5562e+01, -8.7688e+01, -6.5920e+03, + -6.4500e+01, -7.4875e+01, -9.7188e+01, 3.8550e+02, -1.1319e+02, + -7.2062e+01, -6.1688e+01, -7.6720e+03, -6.9920e+03, 3.5475e+02, + -8.1938e+01], + [-7.9375e+01, -8.3000e+01, 4.2600e+02, -8.4080e+03, -7.7160e+03, + -9.4320e+03, -8.9312e+01, 2.5238e+02, -1.4612e+02, -1.0544e+02, + 5.5650e+02, -9.9500e+01, -8.9125e+01, -1.0025e+02, -2.6800e+03, + -8.4080e+03, -3.4840e+03, 4.7300e+02, -1.5112e+02, 5.5200e+02, + -8.0562e+01, -8.4812e+01, -1.3325e+02, -1.1300e+02, -1.1269e+02, + -1.2762e+02, -9.7312e+01, -9.4375e+01, -1.1806e+02, -7.7040e+03, + -9.0250e+01, -1.0650e+02, -1.3700e+02, 5.2500e+02, -1.5900e+02, + -9.6188e+01, -8.7562e+01, -1.0112e+04, -8.4960e+03, 3.4625e+02, + -1.1725e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([ 2, 17, 33, 10, 7, 39, 17, 19]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ 9.7500e+00, 1.6547e+01, 1.1681e+02, -5.3240e+03, -5.0160e+03, + -4.4560e+03, 2.2172e+01, 2.5650e+02, -1.1039e+01, 1.5570e+01, + 8.9625e+01, 1.5211e+01, 1.6641e+01, 1.0445e+01, -1.8970e+03, + -5.1760e+03, -2.0130e+03, 1.5350e+02, -1.3818e+00, 3.7100e+02, + 1.3922e+01, 1.6219e+01, 6.4961e+00, 9.2109e+00, 1.6625e+01, + 2.0527e+00, 1.5523e+01, 1.7719e+01, 1.5547e+01, -5.3920e+03, + 1.9922e+01, 1.8844e+01, -1.1389e-01, 1.0544e+02, 1.0258e+01, + 1.6438e+01, 1.4781e+01, -5.2440e+03, -5.0600e+03, 3.2225e+02, + 1.7031e+01], + [-6.8875e+01, -6.9812e+01, 4.4275e+02, -1.1072e+04, -9.8480e+03, + -1.1984e+04, -7.2000e+01, 4.2650e+02, -1.3838e+02, -9.2688e+01, + 6.5350e+02, -8.5000e+01, -7.2750e+01, -8.7500e+01, -3.4580e+03, + -1.1416e+04, -4.2080e+03, 6.6700e+02, -1.3888e+02, 6.4750e+02, + -6.4875e+01, -7.0938e+01, -1.2206e+02, -1.0169e+02, -1.0175e+02, + -1.1738e+02, -8.6500e+01, -8.1375e+01, -1.0762e+02, -8.9920e+03, + -7.7000e+01, -9.2750e+01, -1.2675e+02, 4.5125e+02, -1.4700e+02, + -8.3188e+01, -7.3500e+01, -1.0544e+04, -1.0368e+04, 4.5025e+02, + -1.0806e+02], + [-8.2875e+01, -8.8188e+01, 4.3450e+02, -7.1240e+03, -6.0880e+03, + -8.8880e+03, -9.2875e+01, 2.5200e+02, -1.5812e+02, -1.1175e+02, + 4.8275e+02, -1.0000e+02, -9.0250e+01, -1.0719e+02, -2.4300e+03, + -6.8840e+03, -2.9540e+03, 5.5600e+02, -1.6738e+02, 4.1200e+02, + -8.0188e+01, -8.4312e+01, -1.4562e+02, -1.1838e+02, -1.1838e+02, + -1.3662e+02, -1.0731e+02, -1.0156e+02, -1.2594e+02, -5.5480e+03, + -1.0112e+02, -1.1862e+02, -1.5000e+02, 4.0075e+02, -1.7488e+02, + -1.0256e+02, -9.1375e+01, -8.3680e+03, -6.8440e+03, 2.8525e+02, + -1.3275e+02], + [ 1.1484e+01, 1.7500e+01, 2.4512e+02, -6.0480e+03, -5.5560e+03, + -5.2960e+03, 1.7594e+01, 2.2625e+02, -1.1453e+01, 1.0031e+01, + 2.1738e+02, 1.0359e+01, 1.5266e+01, 1.2914e+01, -1.9230e+03, + -6.1600e+03, -2.1040e+03, 2.4412e+02, -6.9922e+00, 3.0425e+02, + 1.5914e+01, 1.4203e+01, 4.0430e+00, 7.7188e+00, 1.0305e+01, + 1.6250e+00, 1.5312e+01, 1.6141e+01, 6.4961e+00, -5.5920e+03, + 1.7938e+01, 2.0625e+01, -2.6309e+00, 1.7175e+02, 1.7676e+00, + 1.3414e+01, 1.6734e+01, -5.8240e+03, -5.8040e+03, 2.8275e+02, + 1.5367e+01], + [-8.1875e+01, -8.9500e+01, 3.3225e+02, -6.0240e+03, -4.6200e+03, + -6.3040e+03, -9.5312e+01, 1.1148e+01, -1.3412e+02, -1.0894e+02, + 4.1350e+02, -1.0719e+02, -9.4500e+01, -1.0288e+02, -1.7140e+03, + -5.5480e+03, -2.1140e+03, 4.0400e+02, -1.3725e+02, 4.7025e+02, + -8.5438e+01, -8.8750e+01, -1.2556e+02, -1.1425e+02, -1.1519e+02, + -1.1988e+02, -1.0450e+02, -9.5875e+01, -1.1775e+02, -5.3520e+03, + -9.8500e+01, -1.1150e+02, -1.2862e+02, 4.2750e+02, -1.5000e+02, + -1.0075e+02, -9.4875e+01, -6.6920e+03, -5.3800e+03, 3.3975e+02, + -1.2031e+02], + [-7.9625e+01, -8.7125e+01, 3.3275e+02, -5.9720e+03, -4.5800e+03, + -6.2480e+03, -9.2312e+01, 1.3000e+01, -1.3025e+02, -1.0575e+02, + 4.0375e+02, -1.0400e+02, -9.1188e+01, -9.9812e+01, -1.6760e+03, + -5.5160e+03, -2.0740e+03, 4.0025e+02, -1.3300e+02, 4.6725e+02, + -8.2812e+01, -8.6000e+01, -1.2162e+02, -1.1094e+02, -1.1156e+02, + -1.1612e+02, -1.0169e+02, -9.3062e+01, -1.1450e+02, -5.2880e+03, + -9.5875e+01, -1.0806e+02, -1.2481e+02, 4.1975e+02, -1.4512e+02, + -9.7875e+01, -9.2000e+01, -6.5880e+03, -5.3040e+03, 3.3125e+02, + -1.1619e+02], + [-6.9375e+01, -6.6750e+01, 8.2150e+02, -1.4864e+04, -1.2920e+04, + -1.5600e+04, -7.5000e+01, 5.8300e+02, -1.7112e+02, -9.6375e+01, + 5.8150e+02, -9.1312e+01, -7.3438e+01, -8.7000e+01, -4.6200e+03, + -1.4440e+04, -5.5560e+03, 7.1000e+02, -1.7038e+02, 9.1050e+02, + -6.6062e+01, -6.9938e+01, -1.3350e+02, -1.0769e+02, -1.0312e+02, + -1.3125e+02, -8.2875e+01, -7.7125e+01, -1.1444e+02, -1.1504e+04, + -7.4062e+01, -8.7625e+01, -1.4975e+02, 5.8000e+02, -1.6775e+02, + -8.3562e+01, -7.2438e+01, -1.4664e+04, -1.3128e+04, 7.1100e+02, + -1.0388e+02], + [-7.1688e+01, -7.5062e+01, 4.6875e+02, -6.3800e+03, -5.0800e+03, + -6.8200e+03, -7.6750e+01, 2.2375e+02, -1.2650e+02, -9.4375e+01, + 1.9338e+02, -7.8375e+01, -7.4125e+01, -9.2000e+01, -1.9150e+03, + -5.6760e+03, -2.4940e+03, 4.9850e+02, -1.3800e+02, 3.5775e+02, + -6.7250e+01, -7.0688e+01, -1.2144e+02, -9.9000e+01, -9.8000e+01, + -1.1756e+02, -9.8125e+01, -8.6938e+01, -1.0806e+02, -5.1240e+03, + -8.5250e+01, -1.0069e+02, -1.2256e+02, 3.6675e+02, -1.4812e+02, + -8.6750e+01, -7.7625e+01, -6.7120e+03, -5.7120e+03, 1.3312e+02, + -1.1406e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 33, 17, 7, 10, 19, 2, 39]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -16.0000, -17.0625, 106.9375, -4428.0000, -3784.0000, -3946.0000, + -18.7031, 61.8750, -35.2812, -27.4531, 210.7500, -23.8906, + -18.8594, -23.8281, -1448.0000, -4320.0000, -1592.0000, 200.0000, + -40.8125, 382.0000, -14.7578, -18.1875, -36.9688, -29.8750, + -33.5938, -32.1562, -24.5781, -23.8438, -37.3750, -4328.0000, + -22.0781, -27.6406, -33.6250, 191.5000, -49.3438, -23.5000, + -19.0781, -3402.0000, -3770.0000, 244.2500, -33.2500], + [ -60.3438, -67.5000, 238.5000, -5524.0000, -4392.0000, -5900.0000, + -72.0000, 34.8438, -110.8125, -85.5625, 294.2500, -82.5625, + -72.0625, -80.9375, -1697.0000, -5256.0000, -2076.0000, 407.7500, + -121.9375, 426.2500, -62.2812, -66.6875, -107.7500, -93.0000, + -94.3750, -100.8750, -81.1250, -75.4375, -98.4375, -4904.0000, + -75.8750, -91.3750, -108.0625, 358.7500, -134.0000, -78.2500, + -71.1875, -6200.0000, -4988.0000, 405.5000, -100.8125], + [ -63.4375, -67.8125, 317.2500, -7072.0000, -6136.0000, -8156.0000, + -74.3750, 199.8750, -124.4375, -89.2500, 403.7500, -84.5625, + -74.0000, -81.6875, -2378.0000, -6848.0000, -3052.0000, 437.2500, + -130.2500, 420.5000, -65.8125, -69.3750, -113.5000, -97.4375, + -98.2500, -106.3750, -82.5000, -76.6250, -100.0625, -5888.0000, + -75.9375, -90.6875, -115.0625, 409.7500, -137.6250, -80.1875, + -72.6875, -7396.0000, -6088.0000, 472.0000, -101.3125], + [ -64.5000, -69.1875, 187.2500, -5840.0000, -5028.0000, -5168.0000, + -70.0625, 148.2500, -109.5000, -86.0625, 326.0000, -77.7500, + -72.3125, -85.7500, -1880.0000, -6060.0000, -2242.0000, 391.5000, + -117.5000, 471.2500, -64.3125, -67.9375, -108.3125, -93.8125, + -94.8750, -103.5000, -86.8125, -79.5625, -97.0625, -5516.0000, + -77.2500, -96.3750, -105.9375, 299.2500, -131.0000, -79.1250, + -72.8750, -7076.0000, -6016.0000, 330.2500, -103.0000], + [ -68.1875, -70.8125, 493.7500, -7996.0000, -7164.0000, -9232.0000, + -78.7500, 263.5000, -138.5000, -94.7500, 413.2500, -90.4375, + -76.0625, -87.5000, -2930.0000, -7660.0000, -3232.0000, 523.0000, + -145.1250, 414.0000, -67.3750, -71.7500, -124.6250, -102.8125, + -102.0000, -117.4375, -86.5000, -82.1875, -110.0000, -5836.0000, + -80.8125, -94.7500, -128.7500, 381.5000, -151.2500, -85.7500, + -75.4375, -9336.0000, -7488.0000, 414.5000, -106.4375], + [ -38.1562, -38.1562, 332.0000, -5720.0000, -4496.0000, -5932.0000, + -41.8125, 169.1250, -81.8750, -52.2188, 133.7500, -50.1562, + -42.0625, -49.6875, -1674.0000, -5428.0000, -2078.0000, 337.0000, + -84.4375, 290.0000, -38.5312, -39.3750, -71.0000, -59.1250, + -56.7500, -69.1250, -49.5000, -45.2500, -58.9062, -4376.0000, + -41.5312, -55.7812, -75.3125, 264.7500, -89.3750, -46.2812, + -39.4688, -5440.0000, -4956.0000, 326.7500, -64.1875], + [ -64.6250, -69.1875, 193.5000, -5808.0000, -5012.0000, -5208.0000, + -69.8750, 154.2500, -108.8750, -85.6875, 321.7500, -77.4375, + -71.9375, -85.8750, -1862.0000, -6064.0000, -2230.0000, 391.5000, + -116.8125, 473.0000, -64.0625, -67.7500, -108.0000, -93.4375, + -94.7500, -103.0625, -87.0000, -79.6250, -96.7500, -5452.0000, + -77.1250, -96.3125, -105.5000, 293.7500, -130.6250, -78.9375, + -72.6250, -7040.0000, -5952.0000, 327.2500, -103.0000], + [ -16.7656, -18.1406, 100.3750, -4388.0000, -3758.0000, -3940.0000, + -19.8594, 63.3125, -36.1875, -28.9375, 215.3750, -25.0312, + -20.0156, -24.7812, -1438.0000, -4308.0000, -1574.0000, 199.6250, + -42.3750, 375.0000, -15.5938, -19.1562, -38.5625, -31.0156, + -35.0312, -33.5312, -25.5312, -25.0312, -39.2188, -4284.0000, + -23.3906, -29.0938, -34.8750, 184.1250, -51.2500, -24.6406, + -20.2031, -3456.0000, -3742.0000, 248.5000, -35.0938]], + device='cuda:0', dtype=torch.float16, grad_fn=) tensor([17, 19, 7, 2, 17, 33, 39, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-5.5750e+01, -5.8594e+01, 1.8488e+02, -5.1000e+03, -4.9320e+03, + -5.4120e+03, -6.1719e+01, 8.3938e+01, -9.9312e+01, -7.2500e+01, + 2.7600e+02, -7.2312e+01, -6.4750e+01, -7.1562e+01, -2.1440e+03, + -5.5680e+03, -2.2400e+03, 3.3450e+02, -9.9500e+01, 3.1775e+02, + -5.8062e+01, -6.0969e+01, -9.0375e+01, -7.9875e+01, -7.8875e+01, + -8.7625e+01, -7.1562e+01, -6.5062e+01, -7.8875e+01, -5.2040e+03, + -6.1938e+01, -7.5438e+01, -9.2062e+01, 3.3550e+02, -1.0544e+02, + -6.6562e+01, -6.2875e+01, -6.0320e+03, -5.4480e+03, 3.8825e+02, + -8.2812e+01], + [-6.9312e+01, -7.3500e+01, 2.2512e+02, -5.9480e+03, -5.5200e+03, + -6.4120e+03, -7.7875e+01, 1.3175e+02, -1.2156e+02, -9.1812e+01, + 2.4012e+02, -9.0938e+01, -8.2250e+01, -9.0625e+01, -2.6160e+03, + -6.1760e+03, -2.5880e+03, 4.1075e+02, -1.2381e+02, 4.3775e+02, + -7.3250e+01, -7.6062e+01, -1.1575e+02, -1.0106e+02, -1.0050e+02, + -1.1056e+02, -9.3000e+01, -8.1875e+01, -9.9812e+01, -5.9480e+03, + -7.8625e+01, -9.6625e+01, -1.1362e+02, 3.5200e+02, -1.3338e+02, + -8.2938e+01, -8.0750e+01, -6.5920e+03, -6.0840e+03, 4.2975e+02, + -1.0650e+02], + [-6.3875e+01, -7.0062e+01, 1.4850e+02, -5.2840e+03, -4.5720e+03, + -4.5800e+03, -7.6000e+01, 1.0688e+02, -1.0919e+02, -8.7312e+01, + 4.6025e+02, -8.1438e+01, -7.5125e+01, -7.9750e+01, -2.2000e+03, + -5.4000e+03, -2.1500e+03, 3.5775e+02, -1.1100e+02, 3.7525e+02, + -6.7562e+01, -6.9500e+01, -9.7688e+01, -9.0438e+01, -9.2062e+01, + -9.4562e+01, -8.2125e+01, -7.7375e+01, -9.7875e+01, -4.9600e+03, + -7.6750e+01, -9.1000e+01, -1.0312e+02, 3.3325e+02, -1.2256e+02, + -8.3750e+01, -7.2562e+01, -6.8200e+03, -5.0000e+03, 5.0125e+02, + -9.8312e+01], + [ 1.2172e+01, 1.5453e+01, 8.7500e+01, -7.7000e+02, -8.1400e+02, + -1.4820e+03, 1.3703e+01, -1.5800e+02, 1.0141e+01, 1.7766e+01, + -7.2375e+01, 1.4719e+01, 1.1977e+01, 1.7125e+01, 1.0069e+02, + -1.3260e+03, -2.7750e+02, 2.2469e+01, 9.6406e+00, 3.4406e+01, + 1.5305e+01, 1.2516e+01, 1.7219e+01, 2.0469e+01, 1.9000e+01, + 1.2195e+01, 1.9094e+01, 1.5789e+01, 1.6172e+01, -1.3550e+03, + 1.7016e+01, 2.3750e+01, 9.7969e+00, 5.3656e+01, 1.3344e+01, + 1.8062e+01, 1.5320e+01, -3.8450e+02, -1.2180e+03, 3.2969e+01, + 2.1250e+01], + [-6.7250e+01, -7.4125e+01, 1.6175e+02, -5.4600e+03, -4.6760e+03, + -4.9160e+03, -8.0000e+01, 9.8625e+01, -1.1275e+02, -9.1750e+01, + 4.6700e+02, -8.5562e+01, -7.9062e+01, -8.3625e+01, -2.1820e+03, + -5.5480e+03, -2.1900e+03, 3.7275e+02, -1.1531e+02, 3.8925e+02, + -7.0875e+01, -7.3188e+01, -1.0262e+02, -9.5000e+01, -9.7062e+01, + -9.9125e+01, -8.6188e+01, -8.1750e+01, -1.0306e+02, -5.0560e+03, + -8.1062e+01, -9.5500e+01, -1.0738e+02, 3.5075e+02, -1.2838e+02, + -8.7938e+01, -7.6375e+01, -6.9480e+03, -5.1240e+03, 5.0125e+02, + -1.0312e+02], + [-1.1431e+02, -1.2506e+02, 5.4300e+02, -9.7840e+03, -8.0280e+03, + -1.1344e+04, -1.3350e+02, 1.7100e+02, -2.1275e+02, -1.5700e+02, + 5.6100e+02, -1.4025e+02, -1.3025e+02, -1.4700e+02, -2.7800e+03, + -9.3200e+03, -3.8600e+03, 7.1550e+02, -2.2312e+02, 6.1550e+02, + -1.1750e+02, -1.2244e+02, -1.9200e+02, -1.6400e+02, -1.6412e+02, + -1.8425e+02, -1.4475e+02, -1.4025e+02, -1.7312e+02, -8.2640e+03, + -1.4012e+02, -1.5862e+02, -2.0112e+02, 7.1550e+02, -2.3212e+02, + -1.4450e+02, -1.2950e+02, -1.1848e+04, -9.1280e+03, 5.7300e+02, + -1.7662e+02], + [-2.8703e+01, -3.0969e+01, 1.9962e+02, -4.9640e+03, -4.0680e+03, + -5.1320e+03, -3.3125e+01, 2.2250e+02, -6.7562e+01, -4.4594e+01, + 1.7350e+02, -3.6594e+01, -3.1312e+01, -4.0062e+01, -1.6480e+03, + -4.2880e+03, -1.8790e+03, 2.6225e+02, -7.4875e+01, 3.0425e+02, + -2.7453e+01, -2.9016e+01, -6.1688e+01, -4.8719e+01, -5.0688e+01, + -5.8031e+01, -4.0000e+01, -3.8781e+01, -5.5250e+01, -3.7700e+03, + -3.8562e+01, -4.4031e+01, -6.3906e+01, 1.3288e+02, -8.0312e+01, + -3.8500e+01, -3.2688e+01, -3.8360e+03, -3.9560e+03, 2.7675e+02, + -5.3094e+01], + [-3.1984e+01, -3.3156e+01, 1.0981e+02, -5.0600e+03, -4.1960e+03, + -4.1240e+03, -3.4438e+01, 1.4188e+02, -6.3500e+01, -4.4438e+01, + 1.7725e+02, -4.1281e+01, -3.5750e+01, -4.3125e+01, -1.5600e+03, + -4.5360e+03, -1.6710e+03, 2.2600e+02, -6.5250e+01, 3.0900e+02, + -3.1672e+01, -3.4531e+01, -5.6719e+01, -5.0031e+01, -4.9438e+01, + -5.6125e+01, -4.2344e+01, -3.6688e+01, -4.9156e+01, -4.2080e+03, + -3.7406e+01, -4.7969e+01, -5.8938e+01, 2.0800e+02, -6.9938e+01, + -3.9594e+01, -3.7344e+01, -4.5800e+03, -4.1600e+03, 3.3500e+02, + -5.2000e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 17, 2, 33, 19, 10, 7, 39]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-5.9062e+01, -6.6375e+01, 2.4538e+02, -2.8500e+03, -3.2580e+03, + -4.1040e+03, -7.2875e+01, -1.3812e+02, -9.0125e+01, -7.9562e+01, + 4.1625e+02, -7.7062e+01, -7.1062e+01, -7.1312e+01, -8.9750e+02, + -3.4840e+03, -1.1940e+03, 2.8700e+02, -9.4250e+01, 1.6138e+02, + -6.4062e+01, -6.7688e+01, -8.7062e+01, -8.2125e+01, -8.4562e+01, + -8.2688e+01, -6.7500e+01, -7.1000e+01, -8.5312e+01, -3.5180e+03, + -7.2188e+01, -7.6875e+01, -8.7375e+01, 2.7850e+02, -9.9500e+01, + -7.5188e+01, -6.8562e+01, -5.3000e+03, -3.2340e+03, 1.7988e+02, + -8.3000e+01], + [-9.4438e+01, -1.0488e+02, 3.0200e+02, -7.9320e+03, -6.4640e+03, + -9.4080e+03, -1.1100e+02, 1.0988e+02, -1.6825e+02, -1.3300e+02, + 4.9950e+02, -1.1769e+02, -1.0900e+02, -1.2162e+02, -2.3240e+03, + -7.8520e+03, -3.0780e+03, 6.3850e+02, -1.8112e+02, 5.3800e+02, + -9.5625e+01, -1.0231e+02, -1.5888e+02, -1.3700e+02, -1.4262e+02, + -1.5038e+02, -1.2056e+02, -1.1850e+02, -1.4825e+02, -7.4400e+03, + -1.2081e+02, -1.3362e+02, -1.6325e+02, 5.8000e+02, -1.9575e+02, + -1.2219e+02, -1.0744e+02, -8.0080e+03, -7.2240e+03, 4.7525e+02, + -1.5125e+02], + [-1.0731e+02, -1.1425e+02, 5.5850e+02, -1.1080e+04, -1.0400e+04, + -1.1928e+04, -1.2381e+02, 9.0500e+01, -2.0488e+02, -1.4725e+02, + 9.3900e+02, -1.3900e+02, -1.2356e+02, -1.3338e+02, -3.4320e+03, + -1.1048e+04, -4.5160e+03, 6.9650e+02, -2.1388e+02, 5.0475e+02, + -1.0906e+02, -1.1556e+02, -1.8325e+02, -1.5350e+02, -1.5675e+02, + -1.7550e+02, -1.2900e+02, -1.2962e+02, -1.6650e+02, -1.0288e+04, + -1.2638e+02, -1.4112e+02, -1.9362e+02, 7.4300e+02, -2.2650e+02, + -1.3462e+02, -1.1919e+02, -1.3232e+04, -1.1504e+04, 5.9600e+02, + -1.6425e+02], + [-4.3242e+00, 6.6328e+00, 6.1650e+02, -7.9280e+03, -7.8120e+03, + -7.8440e+03, -2.0234e+00, 3.2825e+02, -5.9469e+01, -9.7188e+00, + 2.0950e+02, -1.5492e+01, -5.7852e+00, -6.3789e+00, -2.7860e+03, + -8.6960e+03, -3.0240e+03, 3.9750e+02, -5.0656e+01, 2.6950e+02, + -2.2207e+00, -2.1348e+00, -2.7859e+01, -1.5086e+01, -6.6992e+00, + -3.4156e+01, 2.9160e+00, 1.9951e+00, -1.1828e+01, -7.3520e+03, + 7.1875e+00, 3.0332e+00, -4.5156e+01, 3.0500e+02, -3.7281e+01, + -3.2812e+00, -1.6572e+00, -8.9440e+03, -8.2000e+03, 3.5275e+02, + -6.1914e+00], + [-5.7094e+01, -5.6812e+01, 1.8250e+02, -9.1600e+03, -8.1320e+03, + -9.9440e+03, -6.1875e+01, 1.6112e+02, -1.2425e+02, -7.8938e+01, + 5.9500e+02, -8.0938e+01, -6.5750e+01, -6.8188e+01, -3.1200e+03, + -8.9600e+03, -3.8200e+03, 6.2400e+02, -1.2244e+02, 4.6775e+02, + -5.6281e+01, -6.1500e+01, -1.0181e+02, -8.3688e+01, -8.3438e+01, + -9.7375e+01, -6.5438e+01, -6.5125e+01, -8.6375e+01, -8.0920e+03, + -6.2750e+01, -6.8750e+01, -1.0969e+02, 6.4100e+02, -1.2188e+02, + -6.9312e+01, -6.1812e+01, -9.4720e+03, -8.9200e+03, 5.4800e+02, + -8.2312e+01], + [-6.3344e+01, -6.9250e+01, 1.7225e+02, -4.1680e+03, -3.8000e+03, + -4.2320e+03, -7.0500e+01, 1.3738e+02, -1.1356e+02, -8.5812e+01, + 4.0600e+02, -7.5875e+01, -6.9812e+01, -8.2875e+01, -1.5530e+03, + -4.2880e+03, -1.7500e+03, 2.5162e+02, -1.2025e+02, 1.9162e+02, + -6.2812e+01, -6.6125e+01, -1.0625e+02, -9.0938e+01, -9.1438e+01, + -1.0112e+02, -8.3750e+01, -7.7812e+01, -9.5562e+01, -3.9620e+03, + -7.7312e+01, -9.1125e+01, -1.0912e+02, 2.9725e+02, -1.2912e+02, + -8.0125e+01, -7.0312e+01, -5.5040e+03, -4.5840e+03, 3.0125e+02, + -1.0194e+02], + [-7.6625e+01, -8.5812e+01, 1.2075e+02, -2.2000e+03, -2.1760e+03, + -3.9120e+03, -8.5625e+01, 3.5812e+01, -1.1300e+02, -9.5812e+01, + 4.0725e+02, -8.7938e+01, -8.4438e+01, -9.6812e+01, -9.7700e+02, + -2.6360e+03, -1.2170e+03, 1.9725e+02, -1.2062e+02, 1.9075e+02, + -7.6500e+01, -7.9938e+01, -1.1231e+02, -1.0000e+02, -1.0394e+02, + -1.0594e+02, -9.8812e+01, -9.1938e+01, -1.0800e+02, -2.6060e+03, + -9.4375e+01, -1.0594e+02, -1.1294e+02, 2.5075e+02, -1.3512e+02, + -9.2188e+01, -8.4000e+01, -2.7300e+03, -2.6820e+03, 2.2162e+02, + -1.1638e+02], + [-1.0850e+02, -1.1875e+02, 3.9475e+02, -7.5200e+03, -6.4560e+03, + -8.3920e+03, -1.2625e+02, 7.0438e+01, -1.7500e+02, -1.4500e+02, + 5.8400e+02, -1.2900e+02, -1.2238e+02, -1.3538e+02, -2.5560e+03, + -7.4640e+03, -2.8220e+03, 5.1850e+02, -1.8588e+02, 4.2050e+02, + -1.1125e+02, -1.1600e+02, -1.6762e+02, -1.4875e+02, -1.5325e+02, + -1.6112e+02, -1.3400e+02, -1.3262e+02, -1.6300e+02, -7.3360e+03, + -1.3212e+02, -1.4888e+02, -1.7362e+02, 6.6350e+02, -2.0688e+02, + -1.3575e+02, -1.2050e+02, -8.4400e+03, -7.2440e+03, 4.0775e+02, + -1.6575e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 10, 7, 17, 33, 2, 39, 19]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-4.0406e+01, -3.9219e+01, 6.4850e+02, -8.7120e+03, -8.2400e+03, + -1.0296e+04, -4.3719e+01, 2.5125e+02, -9.5438e+01, -5.8906e+01, + 3.9700e+02, -5.6531e+01, -4.7625e+01, -5.4094e+01, -3.2440e+03, + -9.5760e+03, -3.6760e+03, 5.3700e+02, -1.0112e+02, 5.0625e+02, + -4.1281e+01, -4.2938e+01, -8.5062e+01, -6.8688e+01, -6.8375e+01, + -8.1750e+01, -4.8906e+01, -4.8688e+01, -6.9750e+01, -8.0120e+03, + -4.4344e+01, -5.7000e+01, -8.9188e+01, 3.4250e+02, -1.0506e+02, + -5.0812e+01, -4.4562e+01, -9.0240e+03, -9.0800e+03, 5.0275e+02, + -7.0000e+01], + [-5.8250e+01, -6.1531e+01, 2.3788e+02, -6.5600e+03, -5.2560e+03, + -5.6200e+03, -6.6250e+01, 2.0725e+02, -1.1938e+02, -8.2250e+01, + 2.5725e+02, -7.7625e+01, -6.8938e+01, -7.5938e+01, -2.3380e+03, + -5.9200e+03, -2.5980e+03, 4.3625e+02, -1.2531e+02, 2.9725e+02, + -5.8781e+01, -6.5438e+01, -1.0631e+02, -8.9188e+01, -8.7438e+01, + -1.0150e+02, -7.8938e+01, -7.1125e+01, -9.3125e+01, -5.5640e+03, + -6.9125e+01, -8.2562e+01, -1.1088e+02, 4.2175e+02, -1.3012e+02, + -7.3812e+01, -6.5938e+01, -6.9760e+03, -6.1120e+03, 4.2175e+02, + -9.2375e+01], + [-1.5525e+02, -1.6850e+02, 8.7750e+02, -1.3936e+04, -1.2248e+04, + -1.6464e+04, -1.7600e+02, 3.4200e+02, -2.9425e+02, -2.0975e+02, + 6.6150e+02, -1.9588e+02, -1.7588e+02, -2.0200e+02, -5.0400e+03, + -1.3512e+04, -5.8960e+03, 9.3950e+02, -3.0775e+02, 7.7100e+02, + -1.5925e+02, -1.6600e+02, -2.6625e+02, -2.2688e+02, -2.2300e+02, + -2.5538e+02, -2.0062e+02, -1.8438e+02, -2.2725e+02, -1.2192e+04, + -1.8238e+02, -2.1938e+02, -2.7825e+02, 9.6350e+02, -3.2150e+02, + -1.8925e+02, -1.7525e+02, -1.6416e+04, -1.3104e+04, 7.8500e+02, + -2.4212e+02], + [-1.2312e+01, -8.0156e+00, 2.2812e+02, -5.8520e+03, -5.4920e+03, + -5.7560e+03, -9.8438e+00, 2.8025e+02, -6.4375e+01, -2.3266e+01, + 1.2825e+02, -2.1141e+01, -1.0797e+01, -1.8594e+01, -2.5620e+03, + -6.0760e+03, -2.6280e+03, 3.2825e+02, -6.1938e+01, 1.8938e+02, + -9.9219e+00, -1.0117e+01, -4.2625e+01, -3.0766e+01, -2.3953e+01, + -4.1250e+01, -1.5852e+01, -1.3922e+01, -2.4250e+01, -5.0000e+03, + -1.1258e+01, -1.9031e+01, -5.1812e+01, 3.2975e+02, -5.4625e+01, + -1.5703e+01, -1.2023e+01, -6.6440e+03, -5.5640e+03, 3.5225e+02, + -2.5797e+01], + [-8.5375e+01, -8.6188e+01, 5.4950e+02, -1.1120e+04, -1.0504e+04, + -1.2696e+04, -9.3125e+01, 3.3525e+02, -1.8362e+02, -1.1625e+02, + 6.8800e+02, -1.1044e+02, -9.3500e+01, -1.0756e+02, -4.0860e+03, + -1.1664e+04, -4.8200e+03, 7.7850e+02, -1.8938e+02, 4.8700e+02, + -8.2062e+01, -8.9188e+01, -1.5450e+02, -1.2694e+02, -1.2250e+02, + -1.4888e+02, -1.0500e+02, -9.9812e+01, -1.2838e+02, -9.6320e+03, + -9.4000e+01, -1.1494e+02, -1.6900e+02, 7.1850e+02, -1.8800e+02, + -1.0312e+02, -9.2500e+01, -1.3848e+04, -1.1752e+04, 6.0150e+02, + -1.2825e+02], + [-5.4094e+01, -5.6531e+01, 2.3575e+02, -6.5000e+03, -5.1960e+03, + -5.6400e+03, -6.0688e+01, 2.0175e+02, -1.1119e+02, -7.5812e+01, + 2.4125e+02, -7.2375e+01, -6.3312e+01, -7.0625e+01, -2.3040e+03, + -5.7960e+03, -2.5440e+03, 4.2525e+02, -1.1706e+02, 2.9425e+02, + -5.4094e+01, -6.0469e+01, -9.9062e+01, -8.2750e+01, -8.1000e+01, + -9.4375e+01, -7.3438e+01, -6.5438e+01, -8.5875e+01, -5.4720e+03, + -6.3375e+01, -7.6188e+01, -1.0338e+02, 4.0925e+02, -1.2112e+02, + -6.7938e+01, -6.0844e+01, -6.7960e+03, -5.9200e+03, 4.1700e+02, + -8.5562e+01], + [-2.8984e+01, -2.2578e+01, 5.5200e+02, -1.0088e+04, -8.7920e+03, + -8.7520e+03, -2.8406e+01, 4.0425e+02, -8.9500e+01, -4.3281e+01, + 2.4650e+02, -3.9594e+01, -2.9594e+01, -4.1000e+01, -2.9280e+03, + -9.1600e+03, -3.4080e+03, 6.4350e+02, -9.0750e+01, 4.4625e+02, + -2.5734e+01, -2.8797e+01, -6.6812e+01, -4.9531e+01, -4.5250e+01, + -6.8812e+01, -3.7375e+01, -3.2156e+01, -4.9125e+01, -7.7640e+03, + -2.6375e+01, -4.1156e+01, -7.8312e+01, 3.3675e+02, -8.5000e+01, + -3.4219e+01, -2.8062e+01, -1.0032e+04, -9.0160e+03, 3.9925e+02, + -5.0281e+01], + [-2.8625e+01, -2.2125e+01, 5.4950e+02, -1.0008e+04, -8.7200e+03, + -8.6480e+03, -2.7859e+01, 3.9975e+02, -8.9250e+01, -4.2875e+01, + 2.5188e+02, -3.9375e+01, -2.9172e+01, -4.0656e+01, -2.9040e+03, + -9.0960e+03, -3.3780e+03, 6.3600e+02, -9.0375e+01, 4.3575e+02, + -2.5531e+01, -2.8391e+01, -6.6438e+01, -4.9312e+01, -4.4750e+01, + -6.8125e+01, -3.6969e+01, -3.1531e+01, -4.8312e+01, -7.6520e+03, + -2.5875e+01, -4.0500e+01, -7.7812e+01, 3.2950e+02, -8.4188e+01, + -3.3938e+01, -2.7828e+01, -9.9840e+03, -8.9360e+03, 3.9850e+02, + -4.9438e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([ 7, 2, 17, 19, 33, 17, 39, 10]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -89.0625, -91.9375, 581.0000, -10232.0000, -9104.0000, + -9512.0000, -98.5000, 371.5000, -179.2500, -123.7500, + 559.0000, -115.0000, -99.0625, -115.3750, -3514.0000, + -9696.0000, -4096.0000, 539.5000, -186.1250, 490.0000, + -89.6250, -94.0000, -159.0000, -133.3750, -130.1250, + -153.8750, -115.6250, -105.6250, -135.7500, -8568.0000, + -100.9375, -124.8750, -166.3750, 555.5000, -191.6250, + -109.8125, -99.0625, -11792.0000, -9648.0000, 460.0000, + -140.1250], + [ -82.3750, -90.4375, 225.7500, -6524.0000, -5220.0000, + -7956.0000, -96.2500, 160.7500, -138.6250, -111.2500, + 397.0000, -105.5625, -94.6250, -106.0625, -1885.0000, + -6096.0000, -2528.0000, 464.5000, -148.2500, 490.2500, + -83.0000, -88.6875, -135.7500, -119.1875, -122.1875, + -126.5625, -108.3125, -101.5000, -125.4375, -6024.0000, + -101.5000, -119.9375, -135.1250, 471.2500, -164.0000, + -102.5625, -94.2500, -6896.0000, -5448.0000, 399.5000, + -131.1250], + [ -55.5312, -53.8750, 792.5000, -11624.0000, -10232.0000, + -13568.0000, -63.7812, 688.5000, -143.8750, -84.8750, + 350.0000, -78.1250, -60.6875, -74.3125, -3674.0000, + -11120.0000, -4448.0000, 681.5000, -148.5000, 508.7500, + -51.5312, -56.1562, -120.3125, -94.8750, -91.1875, + -116.0000, -71.3750, -67.0000, -97.0625, -8416.0000, + -64.3750, -81.1875, -130.5000, 495.5000, -149.5000, + -71.1250, -60.0625, -11832.0000, -10096.0000, 457.2500, + -98.6250], + [ -41.7812, -42.8125, 362.5000, -5132.0000, -4240.0000, + -3130.0000, -45.2812, 218.8750, -75.2500, -57.1875, + 109.8750, -43.9062, -41.8125, -56.4375, -1713.0000, + -4460.0000, -1721.0000, 252.3750, -81.0000, 152.0000, + -40.4062, -42.4688, -69.0625, -58.3750, -57.9062, + -70.5000, -57.4688, -51.3125, -66.8125, -4676.0000, + -49.4688, -58.6875, -72.8125, 288.7500, -86.8750, + -52.9688, -42.7188, -4756.0000, -4932.0000, 181.5000, + -68.3125], + [ -52.9062, -50.5938, 811.5000, -11760.0000, -10400.0000, + -13696.0000, -60.7500, 707.0000, -140.2500, -81.6250, + 339.2500, -75.6875, -57.8125, -71.0625, -3740.0000, + -11232.0000, -4496.0000, 688.0000, -144.5000, 501.2500, + -48.5625, -53.5312, -116.8125, -91.6875, -87.6875, + -112.5000, -68.0625, -63.5000, -93.3125, -8448.0000, + -60.6875, -77.6875, -126.6875, 491.0000, -144.6250, + -67.5625, -57.0625, -11960.0000, -10176.0000, 448.5000, + -94.3750], + [ -23.8906, -23.9062, 126.3125, -3034.0000, -2740.0000, + -4368.0000, -26.9062, 49.5312, -53.5938, -31.2344, + 118.1875, -39.7500, -29.2969, -30.4531, -1197.0000, + -3024.0000, -1150.0000, 278.2500, -52.6562, 83.7500, + -24.2656, -27.9844, -41.2500, -36.2500, -33.9375, + -39.3438, -28.0000, -23.8438, -30.3125, -2084.0000, + -24.4375, -31.5469, -46.9375, 213.0000, -48.7812, + -25.5938, -26.6406, -3386.0000, -2246.0000, 280.5000, + -32.6250], + [ -109.0625, -116.1250, 929.0000, -14736.0000, -12744.0000, + -16688.0000, -128.1250, 639.5000, -246.1250, -163.6250, + 845.5000, -137.5000, -119.8125, -144.0000, -4628.0000, + -14744.0000, -5796.0000, 923.5000, -265.7500, 690.0000, + -106.3750, -113.3750, -216.3750, -174.6250, -175.7500, + -203.6250, -137.3750, -142.2500, -193.8750, -11600.0000, + -141.5000, -159.3750, -232.7500, 719.0000, -280.2500, + -146.3750, -119.8125, -16544.0000, -13824.0000, 830.0000, + -188.6250], + [ -21.9844, -21.4219, 125.5625, -3030.0000, -2712.0000, + -4296.0000, -24.3125, 58.9375, -50.1250, -28.1406, + 111.2500, -36.8750, -26.9375, -27.8125, -1175.0000, + -2950.0000, -1136.0000, 275.0000, -48.5625, 83.7500, + -22.1250, -25.6875, -37.7500, -33.0625, -30.3750, + -36.0938, -25.1250, -21.0469, -26.9844, -2028.0000, + -21.7188, -28.5312, -43.2500, 215.6250, -44.0938, + -22.8750, -24.1875, -3356.0000, -2212.0000, 274.0000, + -28.9062]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([33, 17, 39, 19, 17, 10, 7, 2]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -58.1875, -68.5000, 93.8750, -2376.0000, -1912.0000, + -3116.0000, -71.6875, -21.7344, -87.0000, -81.3125, + 222.3750, -77.2500, -71.3125, -77.5625, -451.7500, + -2068.0000, -870.5000, 312.0000, -94.6875, 192.7500, + -64.0625, -66.1250, -92.6250, -86.1250, -88.3750, + -86.4375, -80.8125, -73.1875, -87.7500, -2758.0000, + -75.4375, -89.1875, -88.3125, 172.6250, -108.9375, + -75.4375, -70.1875, -3136.0000, -2013.0000, 182.6250, + -94.4375], + [ -23.1250, -22.9219, 163.5000, -4804.0000, -4300.0000, + -4488.0000, -26.1406, 321.7500, -50.1250, -35.8438, + 213.2500, -32.9688, -25.7344, -29.4688, -1584.0000, + -4024.0000, -1823.0000, 183.3750, -55.5938, 253.6250, + -23.1094, -24.7812, -47.7812, -38.2188, -41.0938, + -45.6562, -27.7188, -30.4219, -44.5000, -4836.0000, + -29.9062, -33.3438, -48.0625, 231.6250, -63.7812, + -30.8125, -25.8125, -3722.0000, -4016.0000, 145.5000, + -44.5312], + [ -56.4688, -64.0000, 169.8750, -3900.0000, -3296.0000, + -4184.0000, -65.8750, 95.7500, -92.2500, -78.3125, + 190.8750, -73.8125, -66.2500, -76.0000, -1076.0000, + -3590.0000, -1518.0000, 341.7500, -98.6250, 216.1250, + -59.8750, -61.7188, -94.5625, -85.1875, -85.1875, + -89.1250, -79.7500, -69.7500, -84.8125, -3732.0000, + -70.0625, -86.8750, -90.8125, 226.3750, -110.8750, + -71.6250, -65.8750, -4652.0000, -3492.0000, 240.6250, + -92.4375], + [ -18.1562, -16.6719, 270.7500, -5964.0000, -5492.0000, + -5008.0000, -18.9375, 289.2500, -58.1250, -32.1875, + 237.1250, -21.7344, -18.9219, -29.4062, -2802.0000, + -6432.0000, -2160.0000, 363.5000, -66.1875, 161.0000, + -15.4922, -17.6094, -46.3750, -35.0000, -36.2188, + -48.4062, -26.4844, -25.2031, -45.7812, -5688.0000, + -24.2656, -34.5625, -57.4062, 110.6250, -72.5000, + -27.9844, -17.0625, -5888.0000, -5788.0000, 439.5000, + -43.8125], + [ -24.0469, -19.3125, 466.7500, -7980.0000, -7832.0000, + -8968.0000, -21.3438, 461.0000, -81.5625, -32.8438, + 341.5000, -29.4531, -22.0156, -30.4062, -3562.0000, + -9096.0000, -3546.0000, 446.0000, -81.8125, 250.1250, + -18.4688, -20.3281, -56.4062, -40.4375, -37.8750, + -58.4375, -24.4531, -24.3125, -43.4062, -7092.0000, + -21.7969, -27.8438, -71.1250, 296.5000, -75.8750, + -28.1094, -21.0469, -8168.0000, -8360.0000, 534.0000, + -37.3750], + [ -58.4062, -60.9688, 407.5000, -8792.0000, -7504.0000, + -10248.0000, -65.1875, 458.2500, -146.2500, -87.7500, + 428.5000, -79.7500, -65.6250, -79.3750, -3314.0000, + -8464.0000, -3658.0000, 563.0000, -157.1250, 341.7500, + -55.8438, -61.2500, -125.8750, -99.4375, -96.1250, + -116.5000, -78.3125, -73.5000, -100.5625, -7008.0000, + -71.0625, -89.5625, -134.3750, 423.5000, -159.5000, + -74.7500, -65.3750, -9864.0000, -7416.0000, 572.5000, + -104.8750], + [ -30.4219, -26.7188, 455.2500, -7944.0000, -7668.0000, + -8768.0000, -29.2656, 441.7500, -89.3750, -41.2188, + 333.5000, -38.0312, -30.0156, -38.0625, -3404.0000, + -8840.0000, -3504.0000, 458.0000, -89.1875, 282.0000, + -25.7500, -27.8438, -64.5000, -48.8750, -45.5312, + -65.7500, -32.9375, -31.7812, -51.1562, -7088.0000, + -29.3281, -36.8438, -78.6250, 322.7500, -84.1250, + -35.9062, -28.7500, -8384.0000, -8264.0000, 524.0000, + -46.4688], + [ -21.5000, -20.1562, 193.0000, -5088.0000, -4616.0000, + -5096.0000, -23.0625, 325.5000, -51.0625, -32.4688, + 224.3750, -30.2031, -23.1406, -27.2812, -1782.0000, + -4488.0000, -1993.0000, 227.2500, -54.2812, 262.2500, + -20.2500, -22.3906, -44.9062, -34.8125, -36.6875, + -43.1875, -25.2500, -26.8906, -40.8438, -5072.0000, + -25.9531, -29.3281, -47.1875, 241.8750, -59.3125, + -27.6094, -22.7500, -4292.0000, -4492.0000, 184.2500, + -39.8438]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([39, 10, 17, 2, 33, 17, 19, 7]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-6.5000e+01, -6.5875e+01, 4.7850e+02, -1.0064e+04, -9.6240e+03, + -1.1112e+04, -7.2000e+01, 5.7750e+02, -1.5112e+02, -9.4625e+01, + 5.0500e+02, -8.1625e+01, -7.1562e+01, -8.5062e+01, -3.9860e+03, + -1.0072e+04, -4.2200e+03, 6.2950e+02, -1.6175e+02, 4.9675e+02, + -6.1625e+01, -6.5438e+01, -1.2812e+02, -1.0181e+02, -1.0175e+02, + -1.2488e+02, -8.0875e+01, -7.8875e+01, -1.1169e+02, -9.4960e+03, + -7.6688e+01, -9.1438e+01, -1.4150e+02, 5.4300e+02, -1.6475e+02, + -8.2125e+01, -7.0188e+01, -1.1000e+04, -9.9200e+03, 5.6250e+02, + -1.1044e+02], + [-3.6969e+01, -3.7781e+01, 2.0788e+02, -5.4360e+03, -4.8480e+03, + -4.2160e+03, -4.0969e+01, 2.4025e+02, -8.4688e+01, -5.8031e+01, + 2.8250e+02, -4.9531e+01, -4.0562e+01, -5.2156e+01, -1.6740e+03, + -5.5280e+03, -2.0080e+03, 3.3900e+02, -9.3125e+01, 2.2012e+02, + -3.5406e+01, -3.7719e+01, -7.9062e+01, -6.2812e+01, -6.2344e+01, + -7.4438e+01, -5.0781e+01, -4.8812e+01, -6.6688e+01, -5.1600e+03, + -4.6344e+01, -5.9656e+01, -8.1562e+01, 2.5800e+02, -9.9562e+01, + -4.9969e+01, -4.1312e+01, -6.3280e+03, -5.4840e+03, 2.3662e+02, + -7.1250e+01], + [ 4.2109e+00, 1.1734e+01, 2.7225e+02, -6.6440e+03, -6.5640e+03, + -6.9680e+03, 8.3359e+00, 5.2050e+02, -4.1188e+01, -1.2168e+00, + 1.8125e+02, -7.6855e-01, 5.9570e+00, 8.9355e-01, -2.5440e+03, + -7.2040e+03, -2.7540e+03, 4.3500e+02, -3.6438e+01, 2.7525e+02, + 8.2578e+00, 7.0508e+00, -2.0375e+01, -6.3984e+00, -1.6201e+00, + -2.2516e+01, 9.9453e+00, 6.2070e+00, -5.9531e+00, -6.2600e+03, + 8.1797e+00, 6.8945e+00, -3.0281e+01, 1.7800e+02, -2.8375e+01, + 4.0039e+00, 7.8711e+00, -6.6960e+03, -6.6200e+03, 2.5100e+02, + -5.0273e+00], + [ 4.1250e+00, 1.0758e+01, 2.5362e+02, -6.2920e+03, -6.1640e+03, + -6.3640e+03, 7.5703e+00, 4.8100e+02, -3.9156e+01, -2.3320e+00, + 1.7338e+02, -9.1992e-01, 5.5547e+00, 5.5615e-01, -2.3540e+03, + -6.7960e+03, -2.5720e+03, 4.0875e+02, -3.5969e+01, 2.5162e+02, + 7.9531e+00, 6.6367e+00, -2.0922e+01, -7.2148e+00, -2.9004e+00, + -2.2219e+01, 8.5078e+00, 4.8555e+00, -7.2344e+00, -5.9080e+03, + 6.8828e+00, 5.2539e+00, -2.9469e+01, 1.6500e+02, -2.9344e+01, + 2.9648e+00, 7.0312e+00, -6.4240e+03, -6.2880e+03, 2.3662e+02, + -6.1875e+00], + [-9.5438e+01, -1.0206e+02, 3.2950e+02, -1.2064e+04, -9.8240e+03, + -1.2944e+04, -1.1319e+02, 6.3900e+02, -1.9612e+02, -1.3912e+02, + 5.9950e+02, -1.2606e+02, -1.1075e+02, -1.2412e+02, -3.7100e+03, + -1.1272e+04, -4.4560e+03, 7.3550e+02, -2.1050e+02, 6.2200e+02, + -9.4938e+01, -1.0275e+02, -1.7812e+02, -1.4612e+02, -1.4688e+02, + -1.6888e+02, -1.2331e+02, -1.2044e+02, -1.6075e+02, -9.6720e+03, + -1.1975e+02, -1.3750e+02, -1.8588e+02, 6.8700e+02, -2.2388e+02, + -1.2462e+02, -1.0631e+02, -1.1496e+04, -1.0344e+04, 6.1200e+02, + -1.6212e+02], + [-7.0500e+01, -7.5500e+01, 3.4525e+02, -8.8960e+03, -7.3920e+03, + -8.1680e+03, -7.5375e+01, 4.5275e+02, -1.4075e+02, -1.0231e+02, + 5.0400e+02, -8.6625e+01, -7.6250e+01, -9.4875e+01, -2.8160e+03, + -8.5200e+03, -3.3940e+03, 4.4600e+02, -1.5275e+02, 2.7175e+02, + -6.9500e+01, -7.2938e+01, -1.3212e+02, -1.1069e+02, -1.1012e+02, + -1.2550e+02, -9.7562e+01, -8.8000e+01, -1.1512e+02, -7.7240e+03, + -8.7438e+01, -1.0719e+02, -1.3588e+02, 4.2125e+02, -1.6575e+02, + -9.1750e+01, -7.7562e+01, -8.5760e+03, -7.9160e+03, 6.1100e+02, + -1.2206e+02], + [-9.3062e+01, -9.7375e+01, 2.8825e+02, -1.0752e+04, -8.8160e+03, + -1.2032e+04, -1.0350e+02, 6.1450e+02, -1.7825e+02, -1.2800e+02, + 4.4150e+02, -1.1512e+02, -9.8938e+01, -1.1706e+02, -3.1560e+03, + -1.0080e+04, -4.1520e+03, 6.1400e+02, -1.8700e+02, 5.1300e+02, + -8.9250e+01, -9.4500e+01, -1.6325e+02, -1.3750e+02, -1.3750e+02, + -1.5450e+02, -1.1794e+02, -1.1231e+02, -1.4600e+02, -8.4080e+03, + -1.1150e+02, -1.2900e+02, -1.6662e+02, 7.0450e+02, -2.0125e+02, + -1.1625e+02, -9.9750e+01, -1.0944e+04, -9.1600e+03, 4.9350e+02, + -1.4875e+02], + [-9.5562e+01, -1.0250e+02, 3.2975e+02, -1.2080e+04, -9.8320e+03, + -1.2920e+04, -1.1344e+02, 6.4250e+02, -1.9650e+02, -1.3950e+02, + 6.0150e+02, -1.2594e+02, -1.1075e+02, -1.2394e+02, -3.7080e+03, + -1.1224e+04, -4.4560e+03, 7.3150e+02, -2.1050e+02, 6.2250e+02, + -9.5250e+01, -1.0269e+02, -1.7750e+02, -1.4612e+02, -1.4712e+02, + -1.6838e+02, -1.2319e+02, -1.2050e+02, -1.6150e+02, -9.6400e+03, + -1.2044e+02, -1.3688e+02, -1.8575e+02, 6.8500e+02, -2.2375e+02, + -1.2506e+02, -1.0625e+02, -1.1472e+04, -1.0264e+04, 6.1250e+02, + -1.6162e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 39, 17, 2, 7, 10, 19, 33]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-6.3969e+01, -6.6625e+01, 2.3512e+02, -1.1240e+04, -9.2560e+03, + -1.2200e+04, -7.0812e+01, 8.7450e+02, -1.5762e+02, -9.4938e+01, + 3.6625e+02, -8.3750e+01, -6.8750e+01, -8.8812e+01, -3.5540e+03, + -1.0120e+04, -4.3280e+03, 5.0575e+02, -1.6412e+02, 5.5950e+02, + -6.0750e+01, -6.3938e+01, -1.3338e+02, -1.0862e+02, -1.0419e+02, + -1.2775e+02, -8.8125e+01, -7.9125e+01, -1.0831e+02, -8.7520e+03, + -7.7438e+01, -9.9500e+01, -1.4212e+02, 6.2650e+02, -1.7238e+02, + -8.1375e+01, -7.0438e+01, -9.9360e+03, -8.5840e+03, 6.1500e+02, + -1.1981e+02], + [-6.8250e+01, -7.5375e+01, 3.6575e+02, -9.7520e+03, -8.9760e+03, + -9.7120e+03, -7.8312e+01, 6.1600e+02, -1.4800e+02, -1.0531e+02, + 5.9850e+02, -9.0188e+01, -7.9688e+01, -9.3562e+01, -3.4100e+03, + -1.0160e+04, -4.0380e+03, 5.2050e+02, -1.6125e+02, 4.0675e+02, + -6.9875e+01, -7.3250e+01, -1.3812e+02, -1.1444e+02, -1.1562e+02, + -1.3250e+02, -9.3938e+01, -8.9438e+01, -1.2156e+02, -8.8560e+03, + -8.6750e+01, -1.0712e+02, -1.4212e+02, 5.0450e+02, -1.7512e+02, + -9.2000e+01, -7.7688e+01, -1.0576e+04, -1.0008e+04, 4.4000e+02, + -1.2400e+02], + [ 8.9609e+00, 1.7953e+01, 2.7925e+02, -9.3120e+03, -8.4640e+03, + -7.8040e+03, 1.7125e+01, 7.2200e+02, -4.1062e+01, -1.3047e+00, + 2.3250e+02, 1.0117e+01, 1.4094e+01, 3.4824e+00, -3.7500e+03, + -9.2240e+03, -3.6440e+03, 4.5250e+02, -4.7625e+01, 3.0050e+02, + 1.6688e+01, 1.5555e+01, -2.6500e+01, -8.1953e+00, -5.7461e+00, + -3.0984e+01, 8.7344e+00, 5.5781e+00, -1.3359e+01, -8.0720e+03, + 1.0180e+01, 1.9346e+00, -3.4438e+01, 2.7850e+02, -4.8375e+01, + 5.3125e+00, 1.5312e+01, -7.7640e+03, -8.9920e+03, 2.8350e+02, + -1.3188e+01], + [-4.1312e+01, -4.1094e+01, 3.2600e+02, -7.9920e+03, -7.3560e+03, + -7.9360e+03, -4.3812e+01, 5.0925e+02, -1.2194e+02, -6.4875e+01, + 3.4250e+02, -5.2406e+01, -4.2281e+01, -5.9906e+01, -3.6140e+03, + -8.4160e+03, -3.4180e+03, 4.8400e+02, -1.2975e+02, 2.8800e+02, + -3.6156e+01, -4.0312e+01, -9.4938e+01, -7.3562e+01, -6.9062e+01, + -9.2875e+01, -5.5656e+01, -5.1156e+01, -7.4750e+01, -7.2440e+03, + -4.9125e+01, -6.5062e+01, -1.1162e+02, 5.3550e+02, -1.2988e+02, + -5.3688e+01, -4.2156e+01, -9.1440e+03, -8.1280e+03, 2.7925e+02, + -7.7438e+01], + [-7.4062e+01, -7.9688e+01, 2.3525e+02, -8.8400e+03, -6.8480e+03, + -9.2000e+03, -8.5500e+01, 5.7500e+02, -1.5050e+02, -1.0950e+02, + 3.7825e+02, -9.2875e+01, -8.0625e+01, -9.8188e+01, -2.4140e+03, + -7.4920e+03, -2.9700e+03, 3.6925e+02, -1.6188e+02, 4.4075e+02, + -7.1625e+01, -7.5812e+01, -1.3750e+02, -1.1419e+02, -1.1531e+02, + -1.2875e+02, -9.9875e+01, -9.5125e+01, -1.2462e+02, -7.2800e+03, + -9.6188e+01, -1.1081e+02, -1.4375e+02, 5.7700e+02, -1.7562e+02, + -9.7500e+01, -8.0250e+01, -7.5880e+03, -6.4160e+03, 5.1350e+02, + -1.3175e+02], + [-1.0369e+02, -1.1331e+02, 4.2775e+02, -9.5200e+03, -8.5920e+03, + -1.0464e+04, -1.2050e+02, 4.2550e+02, -2.0038e+02, -1.4538e+02, + 5.6900e+02, -1.3038e+02, -1.1762e+02, -1.3562e+02, -3.7460e+03, + -9.7520e+03, -4.1640e+03, 7.2100e+02, -2.1212e+02, 5.6800e+02, + -1.0619e+02, -1.0956e+02, -1.8275e+02, -1.5625e+02, -1.5500e+02, + -1.7525e+02, -1.3475e+02, -1.2506e+02, -1.6138e+02, -8.9200e+03, + -1.2650e+02, -1.5112e+02, -1.9138e+02, 6.0000e+02, -2.2488e+02, + -1.3000e+02, -1.1762e+02, -1.1344e+04, -9.6080e+03, 6.0050e+02, + -1.6800e+02], + [-7.6938e+01, -8.4375e+01, 2.7400e+02, -8.6480e+03, -7.3480e+03, + -8.0920e+03, -8.3938e+01, 5.6700e+02, -1.4212e+02, -1.0881e+02, + 5.1200e+02, -9.2812e+01, -8.5250e+01, -1.0444e+02, -2.7960e+03, + -8.0800e+03, -3.2400e+03, 4.0050e+02, -1.5375e+02, 3.7075e+02, + -7.5812e+01, -8.1625e+01, -1.3650e+02, -1.1756e+02, -1.1875e+02, + -1.3162e+02, -1.0612e+02, -9.6688e+01, -1.2306e+02, -7.7800e+03, + -9.4812e+01, -1.1969e+02, -1.3875e+02, 4.3450e+02, -1.7188e+02, + -9.7812e+01, -8.6312e+01, -7.6120e+03, -7.4520e+03, 5.2900e+02, + -1.3362e+02], + [-6.9250e+01, -7.6688e+01, 3.6975e+02, -9.8000e+03, -9.0400e+03, + -9.7520e+03, -8.0000e+01, 6.2800e+02, -1.4850e+02, -1.0700e+02, + 5.9800e+02, -9.2062e+01, -8.1312e+01, -9.5188e+01, -3.3680e+03, + -1.0144e+04, -4.0580e+03, 5.1800e+02, -1.6250e+02, 4.0950e+02, + -7.0938e+01, -7.4500e+01, -1.4075e+02, -1.1650e+02, -1.1781e+02, + -1.3438e+02, -9.5938e+01, -9.1188e+01, -1.2369e+02, -8.8480e+03, + -8.8375e+01, -1.0975e+02, -1.4300e+02, 5.0475e+02, -1.7775e+02, + -9.3562e+01, -7.9188e+01, -1.0688e+04, -1.0048e+04, 4.4400e+02, + -1.2694e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 10, 19, 33, 17, 2, 39, 7]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -81.9375, -89.3750, 318.7500, -9056.0000, -7324.0000, + -8408.0000, -93.7500, 482.2500, -145.1250, -113.5000, + 334.5000, -97.0625, -88.9375, -110.4375, -2332.0000, + -8392.0000, -3164.0000, 468.2500, -160.3750, 539.5000, + -78.8125, -84.3125, -146.7500, -122.6250, -124.8125, + -141.5000, -114.6875, -103.7500, -134.7500, -7808.0000, + -105.2500, -127.2500, -144.5000, 386.2500, -181.0000, + -104.1875, -90.0000, -8848.0000, -7720.0000, 535.5000, + -144.1250], + [ -57.7188, -58.9688, 291.0000, -7632.0000, -7228.0000, + -7692.0000, -62.3125, 375.7500, -121.8750, -79.7500, + 451.0000, -71.2500, -62.9688, -74.1250, -2976.0000, + -7612.0000, -3182.0000, 446.5000, -123.1250, 416.5000, + -56.5000, -57.8125, -102.3750, -85.7500, -83.3750, + -101.3750, -71.2500, -67.4375, -87.8750, -7172.0000, + -66.0625, -79.3125, -111.0625, 435.0000, -125.1875, + -69.9375, -62.4688, -8264.0000, -7452.0000, 275.7500, + -90.1250], + [ -67.1875, -73.9375, 268.5000, -4376.0000, -4660.0000, + -4648.0000, -79.5000, 173.2500, -119.3125, -94.8125, + 403.7500, -92.6875, -79.4375, -88.0000, -1397.0000, + -4868.0000, -2142.0000, 355.0000, -124.3750, 312.7500, + -71.3750, -73.8125, -116.5000, -101.3750, -101.3125, + -107.0000, -87.8125, -81.3125, -101.1250, -4164.0000, + -80.9375, -100.1250, -113.3750, 350.7500, -134.3750, + -85.5625, -79.1875, -8224.0000, -5180.0000, 177.8750, + -107.6875], + [ -151.2500, -164.5000, 356.0000, -12216.0000, -10736.0000, + -13256.0000, -175.5000, 484.2500, -268.7500, -205.2500, + 884.0000, -192.3750, -171.2500, -187.5000, -3888.0000, + -11608.0000, -4960.0000, 709.0000, -282.2500, 690.5000, + -153.8750, -162.5000, -245.5000, -216.2500, -217.3750, + -234.5000, -188.5000, -180.2500, -225.2500, -10464.0000, + -181.5000, -206.0000, -255.8750, 962.5000, -299.7500, + -188.6250, -169.2500, -14544.0000, -11216.0000, 741.0000, + -227.5000], + [ -69.0000, -67.5000, 397.0000, -12120.0000, -10776.0000, + -11736.0000, -71.1250, 556.0000, -154.5000, -95.2500, + 646.5000, -86.1875, -72.4375, -87.1250, -3644.0000, + -11168.0000, -4724.0000, 692.0000, -157.1250, 764.0000, + -64.6875, -68.8125, -128.2500, -102.8750, -100.3125, + -124.1875, -80.4375, -79.3125, -107.9375, -10912.0000, + -75.6250, -91.6875, -138.2500, 695.5000, -156.5000, + -83.0625, -72.8125, -13000.0000, -11960.0000, 515.5000, + -105.6875], + [ -152.5000, -166.0000, 354.2500, -12280.0000, -10784.0000, + -13296.0000, -177.1250, 482.7500, -271.7500, -207.6250, + 885.0000, -194.2500, -172.6250, -189.6250, -3912.0000, + -11656.0000, -5000.0000, 713.5000, -285.7500, 697.0000, + -155.0000, -163.8750, -248.5000, -218.3750, -219.6250, + -237.3750, -190.6250, -182.0000, -228.0000, -10552.0000, + -183.5000, -208.8750, -258.7500, 962.0000, -303.5000, + -190.7500, -170.6250, -14584.0000, -11304.0000, 745.0000, + -230.6250], + [ -123.1250, -129.5000, 511.5000, -13480.0000, -12136.0000, + -13024.0000, -139.3750, 526.5000, -246.0000, -169.8750, + 829.5000, -156.5000, -137.1250, -154.0000, -4636.0000, + -13176.0000, -5504.0000, 851.0000, -255.3750, 789.0000, + -123.3125, -129.5000, -212.5000, -178.6250, -176.3750, + -205.8750, -152.7500, -148.5000, -190.2500, -12112.0000, + -143.6250, -165.6250, -228.3750, 1019.5000, -263.5000, + -155.1250, -134.3750, -16896.0000, -13864.0000, 570.5000, + -188.7500], + [ -33.1562, -30.1562, 233.3750, -9824.0000, -9144.0000, + -10992.0000, -34.2500, 662.5000, -94.8125, -47.5938, + 440.0000, -47.0312, -34.6250, -42.8750, -3020.0000, + -9072.0000, -3842.0000, 571.5000, -91.2500, 540.5000, + -29.1875, -30.9844, -71.8125, -55.2500, -51.8750, + -70.0000, -39.0000, -35.9375, -55.1875, -8376.0000, + -35.0000, -44.8125, -79.7500, 476.5000, -85.2500, + -39.6250, -33.9062, -10176.0000, -8552.0000, 411.2500, + -54.6250]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 7, 33, 39, 17, 2, 10, 19]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-2.5500e+01, -1.9812e+01, 3.1475e+02, -9.2800e+03, -8.2000e+03, + -7.1120e+03, -2.1594e+01, 4.8125e+02, -8.8875e+01, -4.1031e+01, + 3.3925e+02, -2.8266e+01, -1.8953e+01, -3.6406e+01, -3.8780e+03, + -9.1840e+03, -3.3740e+03, 4.4275e+02, -9.3688e+01, 4.1350e+02, + -1.6078e+01, -1.9141e+01, -6.7000e+01, -4.8594e+01, -4.2625e+01, + -6.8750e+01, -3.3000e+01, -2.8859e+01, -5.1344e+01, -8.4880e+03, + -2.8469e+01, -3.8469e+01, -7.8750e+01, 5.8550e+02, -9.4062e+01, + -3.3344e+01, -2.1125e+01, -8.4240e+03, -8.3840e+03, 1.7488e+02, + -5.1875e+01], + [-1.0838e+02, -1.1519e+02, 3.6500e+02, -1.3272e+04, -1.1368e+04, + -1.4032e+04, -1.2588e+02, 6.8100e+02, -2.2625e+02, -1.5462e+02, + 8.0850e+02, -1.4075e+02, -1.2181e+02, -1.4112e+02, -4.2120e+03, + -1.2608e+04, -5.2720e+03, 8.2800e+02, -2.3938e+02, 7.2300e+02, + -1.0656e+02, -1.1325e+02, -2.0000e+02, -1.6400e+02, -1.6462e+02, + -1.9188e+02, -1.3875e+02, -1.3325e+02, -1.7788e+02, -1.1128e+04, + -1.3425e+02, -1.5462e+02, -2.1238e+02, 6.5550e+02, -2.5350e+02, + -1.4025e+02, -1.1894e+02, -1.3680e+04, -1.1960e+04, 7.3600e+02, + -1.7888e+02], + [-6.5750e+01, -7.1375e+01, 2.6275e+02, -6.0080e+03, -5.4240e+03, + -6.0480e+03, -7.2562e+01, 2.2938e+02, -1.2469e+02, -9.1562e+01, + 4.3525e+02, -8.2438e+01, -7.3812e+01, -8.6125e+01, -2.2060e+03, + -5.7880e+03, -2.4760e+03, 3.0775e+02, -1.3462e+02, 2.4588e+02, + -6.6500e+01, -7.0438e+01, -1.1575e+02, -9.7250e+01, -9.7500e+01, + -1.0944e+02, -8.6625e+01, -8.0750e+01, -1.0075e+02, -5.4560e+03, + -7.9750e+01, -9.4062e+01, -1.1912e+02, 3.9275e+02, -1.4100e+02, + -8.1562e+01, -7.3312e+01, -6.5520e+03, -5.6560e+03, 4.5125e+02, + -1.0538e+02], + [-1.1875e+02, -1.2681e+02, 3.7025e+02, -1.4080e+04, -1.2088e+04, + -1.5424e+04, -1.3850e+02, 7.2150e+02, -2.4412e+02, -1.6800e+02, + 8.5400e+02, -1.5450e+02, -1.3462e+02, -1.5325e+02, -4.4120e+03, + -1.3264e+04, -5.6280e+03, 9.0200e+02, -2.5750e+02, 7.8850e+02, + -1.1788e+02, -1.2500e+02, -2.1588e+02, -1.7775e+02, -1.7938e+02, + -2.0675e+02, -1.5075e+02, -1.4550e+02, -1.9300e+02, -1.1648e+04, + -1.4675e+02, -1.6800e+02, -2.2925e+02, 6.7700e+02, -2.7200e+02, + -1.5262e+02, -1.3075e+02, -1.4520e+04, -1.2560e+04, 8.2150e+02, + -1.9350e+02], + [-8.4062e+01, -8.1250e+01, 3.3550e+02, -1.5272e+04, -1.3864e+04, + -1.6264e+04, -9.2188e+01, 8.5150e+02, -2.1700e+02, -1.2319e+02, + 8.4350e+02, -1.0562e+02, -9.0250e+01, -1.0669e+02, -5.3080e+03, + -1.4848e+04, -6.4080e+03, 9.9700e+02, -2.2212e+02, 1.0150e+03, + -7.8688e+01, -8.3062e+01, -1.7112e+02, -1.3262e+02, -1.2875e+02, + -1.6712e+02, -9.6250e+01, -1.0112e+02, -1.4450e+02, -1.3600e+04, + -9.9250e+01, -1.1112e+02, -1.9288e+02, 7.9000e+02, -2.2300e+02, + -1.0681e+02, -8.8062e+01, -1.5664e+04, -1.5168e+04, 6.1100e+02, + -1.3975e+02], + [-8.6312e+01, -8.6688e+01, 3.6275e+02, -1.4112e+04, -1.2720e+04, + -1.4968e+04, -9.2062e+01, 7.5550e+02, -1.9850e+02, -1.2188e+02, + 6.5050e+02, -1.0400e+02, -9.0688e+01, -1.1269e+02, -4.9720e+03, + -1.3336e+04, -5.6960e+03, 8.3600e+02, -2.0888e+02, 7.9100e+02, + -8.0062e+01, -8.3750e+01, -1.7000e+02, -1.3225e+02, -1.2975e+02, + -1.6525e+02, -1.0831e+02, -1.0481e+02, -1.4250e+02, -1.2288e+04, + -1.0225e+02, -1.2206e+02, -1.8138e+02, 7.7650e+02, -2.1562e+02, + -1.0619e+02, -9.0062e+01, -1.4624e+04, -1.3192e+04, 6.6750e+02, + -1.4462e+02], + [-3.5531e+01, -3.1188e+01, 2.9975e+02, -1.2088e+04, -1.0632e+04, + -1.1464e+04, -3.5312e+01, 6.2100e+02, -1.1656e+02, -5.4844e+01, + 3.6200e+02, -4.4531e+01, -3.4188e+01, -4.8344e+01, -4.6760e+03, + -1.1280e+04, -4.4400e+03, 6.8600e+02, -1.2138e+02, 6.4050e+02, + -2.7609e+01, -3.1672e+01, -8.7625e+01, -6.4000e+01, -6.1094e+01, + -8.9188e+01, -4.5562e+01, -4.1562e+01, -6.9312e+01, -1.0128e+04, + -4.0000e+01, -5.4344e+01, -1.0338e+02, 6.0550e+02, -1.2106e+02, + -4.3375e+01, -3.2688e+01, -1.0576e+04, -1.0120e+04, 4.3600e+02, + -7.0750e+01], + [-5.7625e+01, -6.6188e+01, 2.2000e+02, -2.0020e+03, -1.8020e+03, + -1.6190e+03, -6.6000e+01, -2.8516e+01, -9.2438e+01, -8.0375e+01, + 3.4250e+02, -7.4750e+01, -6.8562e+01, -7.6312e+01, -8.3300e+02, + -2.0520e+03, -8.8600e+02, 4.3938e+01, -1.0275e+02, -2.6141e+01, + -6.2312e+01, -6.6500e+01, -9.3188e+01, -8.3188e+01, -8.5438e+01, + -8.5750e+01, -7.9125e+01, -7.1938e+01, -8.4312e+01, -2.0620e+03, + -7.2000e+01, -8.4500e+01, -9.2500e+01, 2.0375e+02, -1.0962e+02, + -7.2562e+01, -6.7875e+01, -2.5680e+03, -1.9670e+03, 3.6200e+02, + -9.0438e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([39, 19, 2, 17, 10, 17, 7, 33]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ 5.1812e+01, 5.9719e+01, 1.3800e+02, 3.0800e+03, 1.4120e+03, + 5.0680e+03, 6.1688e+01, -3.4800e+02, 7.8375e+01, 6.8625e+01, + -1.9162e+02, 6.4562e+01, 5.7844e+01, 6.2594e+01, -1.6750e+02, + 1.8460e+03, 1.1290e+03, -1.8462e+02, 8.5500e+01, -2.8850e+02, + 5.1906e+01, 5.5438e+01, 8.1250e+01, 7.1812e+01, 7.6375e+01, + 7.0938e+01, 7.1062e+01, 6.6125e+01, 8.0250e+01, 5.6300e+02, + 6.7062e+01, 7.4750e+01, 7.3938e+01, 2.0449e+00, 9.7375e+01, + 6.6000e+01, 5.8156e+01, 3.8440e+03, 1.5070e+03, -5.5000e+02, + 8.0250e+01], + [-4.0125e+01, -4.0500e+01, 2.9150e+02, -7.7680e+03, -7.4800e+03, + -6.3240e+03, -4.4250e+01, 3.7050e+02, -9.4125e+01, -6.4625e+01, + 6.1150e+02, -4.9438e+01, -4.4438e+01, -5.4406e+01, -3.1940e+03, + -7.6720e+03, -3.1740e+03, 4.4000e+02, -1.0406e+02, 3.9075e+02, + -3.7000e+01, -4.1156e+01, -8.5188e+01, -6.8500e+01, -6.9938e+01, + -8.4938e+01, -5.1000e+01, -5.2969e+01, -7.8812e+01, -7.8600e+03, + -5.2281e+01, -6.5188e+01, -9.1312e+01, 3.5325e+02, -1.1612e+02, + -5.4562e+01, -4.3406e+01, -7.5280e+03, -8.3840e+03, 1.7512e+02, + -7.6062e+01], + [-8.7688e+01, -9.2625e+01, 3.7925e+02, -9.8400e+03, -8.2640e+03, + -9.8960e+03, -9.6250e+01, 3.7425e+02, -1.6038e+02, -1.1762e+02, + 6.1200e+02, -1.0988e+02, -9.7125e+01, -1.1231e+02, -2.5620e+03, + -8.9200e+03, -3.6800e+03, 5.6650e+02, -1.6400e+02, 5.5500e+02, + -8.7250e+01, -9.1500e+01, -1.4488e+02, -1.2475e+02, -1.2281e+02, + -1.3750e+02, -1.1175e+02, -1.0088e+02, -1.2706e+02, -8.5840e+03, + -1.0012e+02, -1.2206e+02, -1.4938e+02, 4.4100e+02, -1.7150e+02, + -1.0581e+02, -9.6125e+01, -1.0632e+04, -8.2720e+03, 6.7050e+02, + -1.3288e+02], + [-8.2688e+01, -9.0250e+01, 4.8675e+02, -5.9760e+03, -5.6480e+03, + -4.5320e+03, -9.5062e+01, 2.1938e+02, -1.5850e+02, -1.1969e+02, + 6.4700e+02, -1.0275e+02, -9.3688e+01, -1.1031e+02, -2.0660e+03, + -6.0240e+03, -2.3900e+03, 3.1675e+02, -1.7125e+02, 1.9175e+02, + -8.4812e+01, -8.8062e+01, -1.4650e+02, -1.2512e+02, -1.2344e+02, + -1.4125e+02, -1.0619e+02, -1.0250e+02, -1.2925e+02, -6.0280e+03, + -1.0262e+02, -1.2231e+02, -1.5362e+02, 2.2638e+02, -1.8012e+02, + -1.0700e+02, -9.4250e+01, -8.5200e+03, -6.7840e+03, 3.5625e+02, + -1.3600e+02], + [-6.6625e+01, -6.6562e+01, 3.2175e+02, -1.4072e+04, -1.1840e+04, + -1.4192e+04, -7.1750e+01, 7.3150e+02, -1.6838e+02, -9.6375e+01, + 6.0150e+02, -8.7812e+01, -7.0625e+01, -8.6625e+01, -4.1600e+03, + -1.2560e+04, -5.0800e+03, 8.3600e+02, -1.7188e+02, 7.9000e+02, + -6.0156e+01, -6.6000e+01, -1.3500e+02, -1.0794e+02, -1.0425e+02, + -1.3150e+02, -8.3812e+01, -7.7812e+01, -1.1300e+02, -1.0728e+04, + -7.7562e+01, -9.7875e+01, -1.5125e+02, 4.3875e+02, -1.7600e+02, + -8.2750e+01, -6.9562e+01, -1.3656e+04, -1.1304e+04, 8.0700e+02, + -1.1525e+02], + [-1.3325e+02, -1.4775e+02, 3.5000e+02, -9.5120e+03, -8.3760e+03, + -1.0672e+04, -1.5912e+02, 5.2600e+02, -2.2175e+02, -1.8275e+02, + 9.5850e+02, -1.6900e+02, -1.5300e+02, -1.6488e+02, -1.4150e+03, + -8.6640e+03, -3.6300e+03, 5.8050e+02, -2.3425e+02, 6.1200e+02, + -1.3675e+02, -1.4425e+02, -2.1400e+02, -1.8700e+02, -1.9475e+02, + -2.0062e+02, -1.6700e+02, -1.6512e+02, -2.0725e+02, -8.5840e+03, + -1.6762e+02, -1.8550e+02, -2.1388e+02, 3.7250e+02, -2.6025e+02, + -1.6938e+02, -1.5138e+02, -1.1592e+04, -9.1920e+03, 6.6300e+02, + -2.0450e+02], + [-5.4281e+01, -5.7375e+01, 8.2062e+01, -7.4400e+03, -6.2120e+03, + -7.1640e+03, -6.1531e+01, 3.0000e+02, -1.0862e+02, -7.6688e+01, + 4.2375e+02, -7.3062e+01, -6.1281e+01, -6.7875e+01, -2.0240e+03, + -6.3360e+03, -2.8800e+03, 4.3425e+02, -1.1169e+02, 5.2250e+02, + -5.4938e+01, -5.6625e+01, -9.6125e+01, -8.1125e+01, -8.2562e+01, + -9.1312e+01, -6.8125e+01, -6.5875e+01, -8.5875e+01, -5.8720e+03, + -6.5500e+01, -7.6938e+01, -9.9188e+01, 3.7550e+02, -1.1850e+02, + -6.8312e+01, -6.0781e+01, -7.0320e+03, -5.9800e+03, 3.0525e+02, + -8.6812e+01], + [-5.0000e+01, -5.0562e+01, 3.0875e+02, -8.0480e+03, -7.5200e+03, + -8.7840e+03, -5.4219e+01, 4.1850e+02, -1.0719e+02, -6.9125e+01, + 6.1000e+02, -6.3656e+01, -5.3781e+01, -6.2312e+01, -3.0740e+03, + -8.0920e+03, -3.2740e+03, 4.7000e+02, -1.0706e+02, 4.4850e+02, + -4.8625e+01, -5.1562e+01, -8.6812e+01, -7.3062e+01, -7.1250e+01, + -8.3750e+01, -5.6219e+01, -5.7219e+01, -7.7062e+01, -7.1360e+03, + -5.4781e+01, -6.3469e+01, -9.6375e+01, 4.9025e+02, -1.0744e+02, + -6.1406e+01, -5.2562e+01, -8.3920e+03, -7.6080e+03, 2.7150e+02, + -7.4812e+01]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([10, 2, 33, 7, 17, 19, 39, 17]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[-9.2125e+01, -9.2750e+01, 5.4850e+02, -1.3856e+04, -1.2336e+04, + -1.2672e+04, -9.6188e+01, 5.5750e+02, -1.9538e+02, -1.2625e+02, + 8.4250e+02, -1.1431e+02, -9.6938e+01, -1.1738e+02, -4.9200e+03, + -1.3576e+04, -5.2960e+03, 7.6600e+02, -2.0200e+02, 7.6350e+02, + -8.6750e+01, -9.2250e+01, -1.6600e+02, -1.3675e+02, -1.3175e+02, + -1.6075e+02, -1.1400e+02, -1.0688e+02, -1.4175e+02, -1.2280e+04, + -1.0344e+02, -1.2738e+02, -1.8025e+02, 6.8400e+02, -2.0650e+02, + -1.1188e+02, -9.6188e+01, -1.5568e+04, -1.3416e+04, 6.4000e+02, + -1.4450e+02], + [-8.3312e+01, -8.6938e+01, 3.7275e+02, -1.2808e+04, -1.1384e+04, + -1.3408e+04, -8.7188e+01, 6.7250e+02, -1.7812e+02, -1.1900e+02, + 8.7200e+02, -9.4375e+01, -8.5438e+01, -1.0656e+02, -5.1480e+03, + -1.2808e+04, -5.1000e+03, 6.8550e+02, -1.8912e+02, 7.1250e+02, + -7.5125e+01, -7.9938e+01, -1.5350e+02, -1.2519e+02, -1.2594e+02, + -1.5125e+02, -1.0100e+02, -1.0281e+02, -1.4050e+02, -1.1792e+04, + -1.0206e+02, -1.1825e+02, -1.6825e+02, 5.9500e+02, -2.0250e+02, + -1.0675e+02, -8.5875e+01, -1.2472e+04, -1.1704e+04, 5.8250e+02, + -1.3938e+02], + [-1.3438e+02, -1.4075e+02, 5.5950e+02, -1.4216e+04, -1.2280e+04, + -1.3464e+04, -1.5100e+02, 4.8275e+02, -2.3762e+02, -1.7612e+02, + 7.1450e+02, -1.6600e+02, -1.4912e+02, -1.6425e+02, -4.9520e+03, + -1.3584e+04, -5.6080e+03, 9.0150e+02, -2.4275e+02, 9.5250e+02, + -1.3350e+02, -1.4012e+02, -2.1375e+02, -1.8500e+02, -1.8588e+02, + -2.0912e+02, -1.6412e+02, -1.5650e+02, -1.9950e+02, -1.3288e+04, + -1.5338e+02, -1.7550e+02, -2.2300e+02, 7.5700e+02, -2.5950e+02, + -1.6288e+02, -1.4612e+02, -1.4840e+04, -1.3968e+04, 7.4650e+02, + -1.9350e+02], + [-4.9727e+00, -1.7881e+00, 2.2488e+02, -5.8360e+03, -5.8800e+03, + -6.0760e+03, 3.5879e+00, 2.5100e+02, -3.6312e+01, -9.6094e+00, + 4.1750e+02, -3.2422e+00, 2.9565e-01, -9.2891e+00, -2.9440e+03, + -6.6960e+03, -2.3100e+03, 3.0375e+02, -3.3656e+01, 2.1175e+02, + 1.0117e+00, -1.3989e-01, -1.9797e+01, -1.3906e+01, -7.7773e+00, + -2.3094e+01, -6.6445e+00, -1.4912e+00, -1.1125e+01, -5.5800e+03, + -4.3896e-01, -8.4531e+00, -3.1078e+01, 3.3375e+02, -3.0359e+01, + -4.5508e+00, -1.3367e-01, -4.9960e+03, -5.6760e+03, 1.8238e+02, + -1.6750e+01], + [-9.9875e+01, -1.0575e+02, 6.2400e+02, -1.2760e+04, -1.1632e+04, + -1.1840e+04, -1.0856e+02, 5.5450e+02, -2.1900e+02, -1.4288e+02, + 9.1950e+02, -1.2606e+02, -1.0981e+02, -1.3188e+02, -5.6320e+03, + -1.2448e+04, -5.2760e+03, 7.8750e+02, -2.3188e+02, 6.2900e+02, + -9.7750e+01, -1.0531e+02, -1.8275e+02, -1.5238e+02, -1.5062e+02, + -1.7762e+02, -1.2769e+02, -1.2038e+02, -1.5888e+02, -1.1920e+04, + -1.1800e+02, -1.4425e+02, -2.0412e+02, 6.5000e+02, -2.3675e+02, + -1.2581e+02, -1.0838e+02, -1.3680e+04, -1.2640e+04, 6.0850e+02, + -1.6125e+02], + [-8.6688e+01, -9.4188e+01, 2.6225e+02, -7.9880e+03, -6.3360e+03, + -7.4480e+03, -1.0306e+02, 4.4425e+02, -1.5600e+02, -1.2031e+02, + 4.3925e+02, -1.1012e+02, -9.9062e+01, -1.0981e+02, -1.7100e+03, + -6.7560e+03, -2.8680e+03, 4.0200e+02, -1.6488e+02, 5.7700e+02, + -8.9250e+01, -9.1688e+01, -1.4612e+02, -1.2594e+02, -1.2625e+02, + -1.4138e+02, -1.1019e+02, -1.0675e+02, -1.3375e+02, -6.5240e+03, + -1.0606e+02, -1.2356e+02, -1.4850e+02, 2.7250e+02, -1.7988e+02, + -1.0931e+02, -9.9188e+01, -8.3040e+03, -6.5840e+03, 5.2400e+02, + -1.3900e+02], + [-1.0494e+02, -1.0525e+02, 6.3750e+02, -1.6944e+04, -1.4920e+04, + -1.4840e+04, -1.0662e+02, 6.0950e+02, -2.1625e+02, -1.4050e+02, + 1.0400e+03, -1.2788e+02, -1.0919e+02, -1.3212e+02, -5.4200e+03, + -1.6432e+04, -6.3080e+03, 8.6700e+02, -2.1950e+02, 9.1300e+02, + -9.8688e+01, -1.0431e+02, -1.8275e+02, -1.5238e+02, -1.4625e+02, + -1.7750e+02, -1.2938e+02, -1.1944e+02, -1.5900e+02, -1.5112e+04, + -1.1525e+02, -1.4038e+02, -1.9712e+02, 7.7300e+02, -2.2438e+02, + -1.2644e+02, -1.0850e+02, -1.8320e+04, -1.6320e+04, 8.4600e+02, + -1.5988e+02], + [-7.5688e+01, -7.8812e+01, 1.2762e+02, -1.0648e+04, -8.7040e+03, + -1.1000e+04, -8.3500e+01, 5.5050e+02, -1.6075e+02, -1.0738e+02, + 3.4625e+02, -9.6438e+01, -8.2688e+01, -9.7625e+01, -3.1460e+03, + -9.7600e+03, -4.1640e+03, 6.2400e+02, -1.6650e+02, 6.4550e+02, + -7.2938e+01, -7.7250e+01, -1.4200e+02, -1.1569e+02, -1.1306e+02, + -1.3575e+02, -1.0075e+02, -9.1812e+01, -1.2056e+02, -7.7440e+03, + -8.9688e+01, -1.0962e+02, -1.4675e+02, 4.3050e+02, -1.7525e+02, + -9.4500e+01, -8.1500e+01, -1.0208e+04, -9.0320e+03, 7.3000e+02, + -1.2519e+02]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([17, 7, 19, 2, 33, 17, 10, 39]) +torch.Size([8, 41]) torch.Size([8]) +tensor([[ -45.6250, -45.3125, 341.2500, -8360.0000, -6920.0000, + -6604.0000, -48.1250, 391.5000, -113.9375, -69.4375, + 227.3750, -55.6875, -45.9688, -65.5625, -2376.0000, + -7656.0000, -3122.0000, 491.7500, -119.0625, 442.7500, + -41.8125, -42.9062, -95.5000, -76.3125, -72.1250, + -93.6875, -66.4375, -55.3438, -79.0625, -6820.0000, + -55.2812, -74.3750, -103.2500, 167.2500, -124.6250, + -59.2812, -48.2500, -8264.0000, -7040.0000, 493.5000, + -84.8750], + [ -115.1250, -125.7500, 625.5000, -8088.0000, -7152.0000, + -7240.0000, -133.7500, 379.2500, -199.3750, -158.5000, + 539.5000, -140.7500, -130.2500, -147.3750, -2142.0000, + -7856.0000, -3106.0000, 524.0000, -209.7500, 451.2500, + -118.2500, -123.5000, -184.1250, -162.5000, -164.0000, + -177.1250, -144.8750, -139.6250, -172.6250, -7944.0000, + -140.2500, -163.6250, -192.7500, 305.5000, -226.6250, + -145.1250, -129.8750, -10296.0000, -8040.0000, 594.0000, + -177.3750], + [ -77.5625, -82.1250, 567.0000, -5072.0000, -5440.0000, + -5848.0000, -87.1250, 345.2500, -137.5000, -104.0625, + 516.0000, -96.3750, -88.2500, -96.8125, -3066.0000, + -5944.0000, -2346.0000, 322.7500, -147.1250, 200.7500, + -77.9375, -82.8125, -124.2500, -108.8125, -108.8125, + -120.0000, -96.7500, -91.6875, -112.1250, -5776.0000, + -90.5625, -107.1250, -133.5000, 404.7500, -154.0000, + -96.0625, -85.9375, -7012.0000, -6400.0000, 223.0000, + -118.0000], + [ -73.0000, -73.3750, 590.0000, -11216.0000, -10608.0000, + -10896.0000, -77.9375, 469.5000, -161.0000, -103.1250, + 644.0000, -91.4375, -79.6250, -95.5000, -4268.0000, + -10904.0000, -4572.0000, 770.0000, -166.7500, 571.5000, + -69.8125, -74.3750, -137.0000, -111.5000, -109.3125, + -134.7500, -88.8125, -86.2500, -116.3125, -10992.0000, + -84.1250, -99.1875, -148.0000, 530.5000, -171.8750, + -89.0000, -78.8125, -11616.0000, -11000.0000, 417.5000, + -117.0000], + [ -103.6250, -110.5625, 554.0000, -11968.0000, -11032.0000, + -10920.0000, -118.2500, 622.0000, -221.6250, -150.8750, + 606.0000, -138.3750, -119.7500, -136.5000, -2852.0000, + -11640.0000, -5036.0000, 849.5000, -231.6250, 681.5000, + -104.7500, -110.7500, -196.1250, -162.3750, -158.7500, + -187.7500, -134.3750, -128.1250, -167.0000, -10680.0000, + -125.3125, -151.6250, -204.8750, 333.5000, -242.6250, + -134.2500, -115.8750, -15640.0000, -12424.0000, 704.5000, + -171.8750], + [ -27.5625, -23.9844, 254.6250, -8424.0000, -6840.0000, + -6432.0000, -25.2500, 388.2500, -90.0625, -45.2188, + 139.7500, -33.1875, -23.5156, -43.4062, -2390.0000, + -7536.0000, -3092.0000, 481.5000, -92.6250, 442.0000, + -21.7188, -21.6719, -70.0000, -52.4375, -46.3125, + -70.0000, -45.4375, -32.4688, -53.0625, -6508.0000, + -32.0312, -49.8125, -77.7500, 136.3750, -94.5000, + -36.3438, -26.4688, -7648.0000, -6720.0000, 462.7500, + -58.9688], + [ -32.0625, -29.0312, 253.0000, -6188.0000, -6212.0000, + -7188.0000, -31.7031, 313.5000, -82.9375, -43.5000, + 261.7500, -41.5938, -34.5938, -42.5938, -2860.0000, + -7044.0000, -2850.0000, 459.5000, -79.1875, 351.7500, + -28.0938, -33.0625, -62.8750, -48.3750, -43.4062, + -62.3125, -38.3438, -34.1875, -47.7500, -5616.0000, + -30.3906, -41.5938, -71.8125, 356.7500, -73.1875, + -37.1875, -32.1250, -7076.0000, -5936.0000, 243.6250, + -50.5312], + [ -39.0625, -39.7188, 411.2500, -6432.0000, -6092.0000, + -5884.0000, -44.1875, 193.5000, -86.0000, -56.2812, + 383.5000, -48.1875, -42.7188, -51.3125, -3178.0000, + -6504.0000, -2540.0000, 390.2500, -91.6250, 364.7500, + -37.0938, -41.1562, -70.4375, -58.7500, -58.9062, + -71.9375, -46.9062, -45.3750, -65.1875, -6704.0000, + -45.3750, -54.1250, -81.3125, 391.0000, -91.9375, + -50.2812, -41.4062, -5780.0000, -6608.0000, 168.1250, + -62.9062]], device='cuda:0', dtype=torch.float16, + grad_fn=) tensor([33, 39, 7, 10, 17, 17, 2, 19]) +subj_list [1] num_sessions 40 +model_name: testing +--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=testing --no-multi_subject --subj=1 --batch_size=8 --num_sessions=40 --hidden_dim=1024 --clip_scale=1. --no-blurry_recon --blur_scale=.5 --use_prior --prior_scale=30 --n_blocks=4 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug --ckpt_interval=999 --no-ckpt_saving --wandb_log +The autoreload extension is already loaded. To reload it, use: + %reload_ext autoreload +subj_list [1] num_sessions 40 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..50e0d3d69897318dd1392b05951c7b32a37ce997 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt @@ -0,0 +1,214 @@ +Babel==2.15.0 +CoCa-pytorch==0.1.0 +GitPython==3.1.43 +Jinja2==3.1.4 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Pygments==2.18.0 +QtPy==2.4.1 +Send2Trash==1.8.3 +absl-py==2.1.0 +accelerate==0.24.1 +aiohttp==3.9.5 +aiosignal==1.3.1 +annotated-types==0.7.0 +antlr4-python3-runtime==4.9.3 +anyio==4.4.0 +argon2-cffi-bindings==21.2.0 +argon2-cffi==23.1.0 +arrow==1.3.0 +asttokens==2.4.1 +async-lru==2.0.4 +attrs==23.2.0 +beartype==0.18.5 +beautifulsoup4==4.12.3 +bleach==6.1.0 +braceexpand==0.1.7 +certifi==2024.6.2 +cffi==1.16.0 +charset-normalizer==3.3.2 +click==8.1.7 +clip-anytorch==2.6.0 +clip==1.0 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +dalle2-pytorch==1.15.6 +datasets==2.20.0 +debugpy==1.8.1 +decorator==5.1.1 +deepspeed==0.13.1 +defusedxml==0.7.1 +diffusers==0.23.0 +dill==0.3.8 +docker-pycreds==0.4.0 +einops==0.8.0 +einx==0.3.0 +ema-pytorch==0.5.0 +embedding-reader==1.7.0 +evaluate==0.4.1 +executing==2.0.1 +fastjsonschema==2.20.0 +filelock==3.15.1 +fonttools==4.53.0 +fqdn==1.5.1 +frozendict==2.4.4 +frozenlist==1.4.1 +fsspec==2024.5.0 +ftfy==6.2.0 +gitdb==4.0.11 +h11==0.14.0 +h5py==3.10.0 +hjson==3.1.0 +httpcore==1.0.5 +httpx==0.27.0 +huggingface-hub==0.23.4 +idna==3.7 +imageio==2.34.1 +importlib_metadata==7.1.0 +ipykernel==6.29.4 +ipython==8.25.0 +ipywidgets==8.1.3 +isoduration==20.11.0 +jedi==0.19.1 +joblib==1.4.2 +json5==0.9.25 +jsonpointer==3.0.0 +jsonschema-specifications==2023.12.1 +jsonschema==4.22.0 +jupyter-console==6.6.3 +jupyter-events==0.10.0 +jupyter-lsp==2.2.5 +jupyter==1.0.0 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +jupyter_server==2.14.1 +jupyter_server_terminals==0.5.3 +jupyterlab==4.2.2 +jupyterlab_nvdashboard==0.11.0 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.27.2 +jupyterlab_widgets==3.0.11 +kiwisolver==1.4.5 +kornia==0.7.1 +lazy_loader==0.4 +lightning-utilities==0.11.2 +matplotlib-inline==0.1.7 +matplotlib==3.8.2 +mistune==3.0.2 +mpmath==1.3.0 +multidict==6.0.5 +multiprocess==0.70.16 +nbclient==0.10.0 +nbconvert==7.16.4 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.3 +ninja==1.11.1.1 +nltk==3.8.1 +notebook==7.2.1 +notebook_shim==0.2.4 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.18.1 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +omegaconf==2.3.0 +open-clip-torch==2.24.0 +overrides==7.7.0 +packaging==24.1 +pandas==2.2.0 +pandocfilters==1.5.1 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.3.0 +pip==24.0 +platformdirs==4.2.2 +prometheus_client==0.20.0 +prompt_toolkit==3.0.47 +protobuf==5.27.1 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +pyarrow-hotfix==0.6 +pyarrow==15.0.2 +pycparser==2.22 +pydantic==2.7.4 +pydantic_core==2.18.4 +pynvml==11.5.0 +pyparsing==3.1.2 +python-dateutil==2.9.0.post0 +python-json-logger==2.0.7 +pytorch-lightning==2.0.1 +pytorch-warmup==0.1.1 +pytz==2024.1 +pyzmq==26.0.3 +qtconsole==5.5.2 +referencing==0.35.1 +regex==2024.5.15 +requests==2.32.3 +resize-right==0.0.2 +responses==0.18.0 +rfc3339-validator==0.1.4 +rfc3986-validator==0.1.1 +rotary-embedding-torch==0.6.2 +rouge_score==0.1.2 +rpds-py==0.18.1 +safetensors==0.4.3 +scikit-image==0.22.0 +scikit-learn==1.5.0 +scipy==1.13.1 +sentence-transformers==2.5.1 +sentencepiece==0.2.0 +sentry-sdk==2.5.1 +setproctitle==1.3.3 +setuptools==65.5.0 +six==1.16.0 +smmap==5.0.1 +sniffio==1.3.1 +soupsieve==2.5 +stack-data==0.6.3 +sympy==1.12.1 +terminado==0.18.1 +threadpoolctl==3.5.0 +tifffile==2024.5.22 +timm==1.0.3 +tinycss2==1.3.0 +tokenizers==0.15.2 +torch-fidelity==0.3.0 +torch==2.1.0 +torchmetrics==1.3.0.post0 +torchvision==0.16.0 +tornado==6.4.1 +tqdm==4.66.4 +traitlets==5.14.3 +transformers==4.37.2 +triton==2.1.0 +types-python-dateutil==2.9.0.20240316 +typing_extensions==4.12.2 +tzdata==2024.1 +umap==0.1.1 +uri-template==1.3.0 +urllib3==2.2.1 +vector-quantize-pytorch==1.14.24 +wandb==0.17.1 +wcwidth==0.2.13 +webcolors==24.6.0 +webdataset==0.2.73 +webencodings==0.5.1 +websocket-client==1.8.0 +widgetsnbextension==4.0.11 +x-clip==0.14.4 +xformers==0.0.22.post7 +xxhash==3.4.1 +yarl==1.9.4 +zipp==3.19.2 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-metadata.json b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..b3a6e81ab4769cb0c749475e730644671a5c3413 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-metadata.json @@ -0,0 +1,1035 @@ +{ + "os": "Linux-5.15.0-1058-aws-x86_64-with-glibc2.31", + "python": "3.11.9", + "heartbeatAt": "2024-06-18T12:36:15.404626", + "startedAt": "2024-06-18T12:36:14.302258", + "docker": null, + "cuda": null, + "args": [], + "state": "running", + "program": "ckadirt/MindEyeV2/src/TrainCluster.ipynb", + "codePathLocal": null, + "root": "/weka/proj-fmri/ckadirt/MindEyeV2", + "git": { + "remote": "https://github.com/MedARC-AI/MindEyeV2.git", + "commit": "a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe" + }, + "email": null, + "host": "ip-10-0-149-152", + "username": "ckadirt", + "executable": "/admin/home-ckadirt/fmri/bin/python3.11", + "cpu_count": 96, + "cpu_count_logical": 192, + "cpu_freq": { + "current": 2710.1276875, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2925.786, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3596.327, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.513, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3599.095, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.548, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.825, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.706, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3599.237, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.748, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3587.835, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.601, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3595.424, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.911, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2650.0, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 232.4169158935547, + "used": 181.67956161499023 + } + }, + "gpu": "NVIDIA H100 80GB HBM3", + "gpu_count": 8, + "gpu_devices": [ + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 1999.9625205993652 + } +} diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..108ea1a9183cc92985b238e75d8eb973749f69dd --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/loss": 149.35307167663575, "test/loss": 1460.2626953125, "train/lr": 0.0002978457718582204, "train/num_steps": 37500, "test/num_steps": 10, "train/fwd_pct_correct": 0.6664333333333333, "train/bwd_pct_correct": 0.6865, "test/test_fwd_pct_correct": 0.5600000023841858, "test/test_bwd_pct_correct": 0.5333333611488342, "train/loss_clip_total": 0.5423962022828559, "train/loss_blurry_total": 0.0, "train/loss_blurry_cont_total": 0.0, "test/loss_clip_total": 2.158545970916748, "train/blurry_pixcorr": 0.0, "test/blurry_pixcorr": 0.0, "train/recon_cossim": 0.0, "test/recon_cossim": 0.0, "train/recon_mse": 0.0, "test/recon_mse": 0.0, "train/loss_prior": 0.0, "test/loss_prior": 0.0, "train/loss_RR": 148.81067535298666, "test/loss_RR": 1458.1041259765625, "_timestamp": 1718717027.775746, "_runtime": 2853.353439092636, "_step": 9, "_wandb": {"runtime": 3000}} \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug-internal.log b/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..a1fa0522e8cf5b5cd8ddf4874bdb72903c8ca0f3 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug-internal.log @@ -0,0 +1,1608 @@ +2024-06-18 12:36:14,422 INFO StreamThr :458031 [internal.py:wandb_internal():85] W&B internal server running at pid: 458031, started at: 2024-06-18 12:36:14.418586 +2024-06-18 12:36:14,423 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status +2024-06-18 12:36:14,445 INFO WriterThread:458031 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/run-testing.wandb +2024-06-18 12:36:14,449 DEBUG SenderThread:458031 [sender.py:send():379] send: header +2024-06-18 12:36:14,558 DEBUG SenderThread:458031 [sender.py:send():379] send: run +2024-06-18 12:36:14,571 INFO SenderThread:458031 [sender.py:_setup_resume():749] checking resume status for None/mindeye_semantic_cluster/testing +2024-06-18 12:36:15,120 INFO SenderThread:458031 [dir_watcher.py:__init__():211] watching files in: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files +2024-06-18 12:36:15,120 INFO SenderThread:458031 [sender.py:_start_run_threads():1188] run started: testing with start time 1718714174.422307 +2024-06-18 12:36:15,150 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: check_version +2024-06-18 12:36:15,150 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: check_version +2024-06-18 12:36:15,215 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: run_start +2024-06-18 12:36:15,305 DEBUG HandlerThread:458031 [system_info.py:__init__():26] System info init +2024-06-18 12:36:15,305 DEBUG HandlerThread:458031 [system_info.py:__init__():41] System info init done +2024-06-18 12:36:15,306 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:15,306 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:15,306 INFO HandlerThread:458031 [system_monitor.py:probe():214] Collecting system info +2024-06-18 12:36:15,306 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:15,306 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 12:36:15,307 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 12:36:15,307 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 12:36:15,307 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 12:36:15,404 DEBUG HandlerThread:458031 [system_info.py:probe():152] Probing system +2024-06-18 12:36:15,412 DEBUG HandlerThread:458031 [system_info.py:_probe_git():137] Probing git +2024-06-18 12:36:15,435 DEBUG HandlerThread:458031 [system_info.py:_probe_git():145] Probing git done +2024-06-18 12:36:15,435 DEBUG HandlerThread:458031 [system_info.py:probe():200] Probing system done +2024-06-18 12:36:15,435 DEBUG HandlerThread:458031 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-1058-aws-x86_64-with-glibc2.31', 'python': '3.11.9', 'heartbeatAt': '2024-06-18T12:36:15.404626', 'startedAt': '2024-06-18T12:36:14.302258', 'docker': None, 'cuda': None, 'args': (), 'state': 'running', 'program': 'ckadirt/MindEyeV2/src/TrainCluster.ipynb', 'codePathLocal': None, 'root': '/weka/proj-fmri/ckadirt/MindEyeV2', 'git': {'remote': 'https://github.com/MedARC-AI/MindEyeV2.git', 'commit': 'a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe'}, 'email': None, 'host': 'ip-10-0-149-152', 'username': 'ckadirt', 'executable': '/admin/home-ckadirt/fmri/bin/python3.11', 'cpu_count': 96, 'cpu_count_logical': 192, 'cpu_freq': {'current': 2710.1276875, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2925.786, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 3596.327, 'min': 0.0, 'max': 0.0}, {'current': 3597.513, 'min': 0.0, 'max': 0.0}, {'current': 3599.095, 'min': 0.0, 'max': 0.0}, {'current': 3597.548, 'min': 0.0, 'max': 0.0}, {'current': 3598.825, 'min': 0.0, 'max': 0.0}, {'current': 3597.706, 'min': 0.0, 'max': 0.0}, {'current': 3599.237, 'min': 0.0, 'max': 0.0}, {'current': 3597.748, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 3587.835, 'min': 0.0, 'max': 0.0}, {'current': 3597.601, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 3595.424, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 3597.911, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}, {'current': 2650.0, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 232.4169158935547, 'used': 181.67956161499023}}, 'gpu': 'NVIDIA H100 80GB HBM3', 'gpu_count': 8, 'gpu_devices': [{'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}], 'memory': {'total': 1999.9625205993652}} +2024-06-18 12:36:15,435 INFO HandlerThread:458031 [system_monitor.py:probe():224] Finished collecting system info +2024-06-18 12:36:15,435 INFO HandlerThread:458031 [system_monitor.py:probe():227] Publishing system info +2024-06-18 12:36:15,435 DEBUG HandlerThread:458031 [system_info.py:_save_code():44] Saving code +2024-06-18 12:36:15,435 WARNING HandlerThread:458031 [system_info.py:_save_code():46] unable to save code -- program entry not found +2024-06-18 12:36:15,435 DEBUG HandlerThread:458031 [system_info.py:_save_patches():84] Saving git patches +2024-06-18 12:36:16,057 DEBUG HandlerThread:458031 [system_info.py:_save_patches():126] Saving git patches done +2024-06-18 12:36:16,062 INFO HandlerThread:458031 [system_monitor.py:probe():229] Finished publishing system info +2024-06-18 12:36:16,071 DEBUG SenderThread:458031 [sender.py:send():379] send: files +2024-06-18 12:36:16,071 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-metadata.json with policy now +2024-06-18 12:36:16,071 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file diff.patch with policy now +2024-06-18 12:36:16,125 INFO Thread-12 :458031 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/diff.patch +2024-06-18 12:36:16,125 INFO Thread-12 :458031 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-metadata.json +2024-06-18 12:36:16,479 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: python_packages +2024-06-18 12:36:16,479 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: python_packages +2024-06-18 12:36:16,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:36:16,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: internal_messages +2024-06-18 12:36:16,484 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:36:16,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 12:36:16,490 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 12:36:16,490 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 12:36:16,490 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:36:16,491 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 12:36:16,491 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 12:36:16,491 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 12:36:16,491 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 12:36:16,597 INFO wandb-upload_0:458031 [upload_job.py:push():130] Uploaded file /tmp/tmplwxz0bb7wandb/0dr6yzkz-wandb-metadata.json +2024-06-18 12:36:16,657 DEBUG SenderThread:458031 [sender.py:send():379] send: telemetry +2024-06-18 12:36:16,779 INFO wandb-upload_1:458031 [upload_job.py:push():130] Uploaded file /tmp/tmplwxz0bb7wandb/92on833k-diff.patch +2024-06-18 12:36:17,141 INFO Thread-12 :458031 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt +2024-06-18 12:36:18,593 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 12:36:18,593 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 12:36:18,593 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 12:36:18,593 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 12:36:18,593 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 12:36:18,593 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:18,594 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:18,594 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:36:18,594 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 12:36:18,596 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 12:36:18,596 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 12:36:18,596 WARNING HandlerThread:458031 [interfaces.py:finish():205] Failed to finish cpu monitoring: cannot join thread before it is started +2024-06-18 12:36:18,596 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:18,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:36:18,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 12:36:18,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 12:36:18,597 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 12:36:18,597 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 12:36:18,597 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:18,597 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:18,597 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 12:36:18,598 WARNING HandlerThread:458031 [interfaces.py:finish():205] Failed to finish cpu monitoring: cannot join thread before it is started +2024-06-18 12:36:18,598 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 12:36:18,598 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:18,598 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:18,598 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 12:36:18,598 WARNING HandlerThread:458031 [interfaces.py:finish():205] Failed to finish cpu monitoring: cannot join thread before it is started +2024-06-18 12:36:18,598 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 12:36:18,598 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 12:36:18,598 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 12:36:18,598 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:18,599 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:18,599 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 12:36:18,599 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 12:36:18,599 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 12:36:18,599 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:18,599 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:36:18,599 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 12:36:18,599 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 12:36:18,603 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 12:36:18,603 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 12:36:18,603 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 12:36:18,603 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 12:36:18,603 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 12:36:18,603 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: internal_messages +2024-06-18 12:36:18,604 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 12:36:18,606 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 12:36:18,609 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 12:36:18,610 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 12:36:18,610 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:36:18,611 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 12:36:19,167 INFO Thread-12 :458031 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:36:19,611 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:21,194 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:36:25,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:30,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:31,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:36:31,480 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:36:35,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:41,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:46,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:36:46,480 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:36:46,656 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:47,559 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml +2024-06-18 12:36:52,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:36:58,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:01,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:37:01,480 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:37:03,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:09,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:15,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:16,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:37:16,480 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:37:18,611 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 12:37:18,613 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:37:20,614 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:26,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:31,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:37:31,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:37:31,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:37,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:42,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:46,480 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:37:46,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:37:47,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:48,614 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:37:53,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:37:58,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:01,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:38:01,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:38:03,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:09,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:15,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:16,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:38:16,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:38:18,618 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:38:20,619 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:26,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:31,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:38:31,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:38:31,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:37,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:43,483 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:46,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:38:46,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:38:48,617 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:38:48,619 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:54,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:38:59,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:01,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:39:01,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:39:04,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:10,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:15,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:16,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:39:16,481 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:39:18,619 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:39:20,620 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:26,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:31,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:39:31,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:39:31,582 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:37,484 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:42,485 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:46,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:39:46,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:39:47,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:48,620 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:39:53,485 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:39:58,485 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:01,481 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:40:01,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:40:03,663 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:09,485 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:14,485 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:16,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:40:16,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:40:18,622 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:40:19,623 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:25,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:30,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:31,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:40:31,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:40:35,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:41,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:46,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:40:46,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:40:46,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:48,626 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:40:52,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:40:57,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:01,482 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:41:01,482 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:41:02,656 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:08,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:13,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:16,486 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:41:16,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:41:18,625 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:41:18,626 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:24,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:29,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:31,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:41:31,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:41:34,664 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:40,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:45,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:46,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:41:46,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:41:48,626 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:41:50,628 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:41:52,364 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 12:41:52,365 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 12:41:52,365 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 12:41:52,371 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 12:41:52,636 INFO Thread-12 :458031 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 12:41:53,648 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:41:55,673 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:41:56,372 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:01,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:42:01,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:42:01,661 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:07,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:12,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:16,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:42:16,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:42:17,661 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:18,628 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:42:23,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:28,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:31,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:42:31,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:42:33,660 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:39,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:44,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:46,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:42:46,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:42:48,633 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:42:49,634 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:42:55,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:00,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:01,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:43:01,487 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:43:05,660 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:11,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:16,487 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:43:16,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:43:16,660 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:18,631 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:43:22,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:27,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:31,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:43:31,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:43:32,661 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:38,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:44,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:46,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:43:46,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:43:48,634 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:43:49,634 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:43:55,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:00,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:01,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:44:01,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:44:05,662 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:11,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:16,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:44:16,488 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:44:16,662 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:18,634 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:44:22,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:27,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:31,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:44:31,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:44:32,662 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:38,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:43,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:46,488 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:44:46,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:44:48,638 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:44:48,640 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:44:54,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:00,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:01,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:45:01,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:45:05,665 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:11,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:16,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:45:16,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:45:16,662 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:18,637 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:45:22,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:28,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:31,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:45:31,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:45:33,663 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:39,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:44,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:46,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:45:46,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:45:48,639 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:45:49,640 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:45:55,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:00,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:01,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:46:01,489 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:46:05,663 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:11,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:16,489 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:46:16,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:46:16,664 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:18,640 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:46:22,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:28,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:31,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:46:31,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:46:33,666 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:33,667 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 12:46:33,667 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 12:46:33,668 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 12:46:33,680 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 12:46:34,223 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 12:46:35,268 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:46:39,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:41,700 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: keepalive +2024-06-18 12:46:44,741 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:46,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:46:46,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:46:48,653 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:46:50,654 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:46:55,700 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:00,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:01,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:47:01,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:47:05,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:10,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:15,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:16,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:47:16,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:47:18,643 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:47:21,644 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:26,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:31,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:47:31,490 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:47:32,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:37,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:42,701 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:46,490 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:47:46,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:47:48,645 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:47:48,646 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:53,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:47:59,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:01,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:48:01,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:48:05,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:10,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:15,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:16,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:48:16,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:48:18,645 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:48:21,646 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:26,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:31,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:48:31,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:48:32,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:37,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:42,702 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:46,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:48:46,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:48:48,649 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:48:48,650 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:53,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:48:58,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:01,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:49:01,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:49:04,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:09,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:14,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:16,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:49:16,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:49:18,648 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:49:20,649 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:25,703 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:30,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:31,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:49:31,491 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:49:36,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:42,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:46,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:49:46,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:49:48,651 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:49:48,651 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:53,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:49:59,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:01,491 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:50:01,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:50:05,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:10,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:15,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:16,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:50:16,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:50:18,651 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:50:21,652 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:26,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:31,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:50:31,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:50:32,704 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:37,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:42,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:46,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:50:46,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:50:48,655 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:50:48,657 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:53,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:50:59,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:01,492 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:51:01,492 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:51:05,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:10,706 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:11,828 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 12:51:11,830 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 12:51:11,830 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 12:51:11,841 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 12:51:12,006 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 12:51:13,017 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:51:14,035 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:51:15,843 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:16,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:51:16,493 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:51:18,654 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:51:21,656 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:26,708 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:31,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:51:31,493 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:51:31,708 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:36,709 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:41,709 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:46,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:51:46,493 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:51:46,709 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:48,657 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:51:52,709 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:51:57,709 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:01,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:52:01,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:52:03,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:08,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:13,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:16,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:52:16,493 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:52:18,657 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:52:19,658 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:24,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:30,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:31,493 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:52:31,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:52:35,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:40,710 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:46,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:52:46,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:52:46,666 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:48,661 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:52:51,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:52:56,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:01,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:53:01,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:53:02,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:07,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:12,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:16,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:53:16,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:53:18,660 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:53:18,661 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:23,711 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:28,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:31,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:53:31,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:53:34,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:39,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:44,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:46,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:53:46,494 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:53:48,663 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:53:50,664 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:53:55,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:00,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:01,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:54:01,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:54:05,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:10,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:15,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:16,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:54:16,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:54:18,664 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:54:21,665 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:26,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:31,494 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:54:31,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:54:32,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:37,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:43,713 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:46,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:54:46,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:54:48,668 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:54:49,669 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:54:54,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:00,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:01,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:55:01,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:55:05,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:10,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:15,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:16,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:55:16,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:55:18,666 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:55:21,668 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:26,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:31,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:55:31,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:55:32,714 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:37,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:42,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:46,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:55:46,495 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:55:48,669 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:55:48,670 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:50,532 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 12:55:50,532 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 12:55:50,532 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 12:55:50,545 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 12:55:50,681 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 12:55:51,693 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 12:55:53,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:55:58,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:01,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:56:01,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:56:04,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:09,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:14,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:16,495 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:56:16,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:56:18,670 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:56:20,671 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:25,716 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:31,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:56:31,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:56:31,669 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:36,722 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:42,716 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:46,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:56:46,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:56:48,674 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:56:48,676 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:53,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:56:58,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:01,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:57:01,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:57:04,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:09,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:15,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:16,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:57:16,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:57:18,673 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:57:21,675 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:26,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:31,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:57:31,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:57:32,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:37,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:42,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:46,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:57:46,496 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:57:48,676 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:57:48,676 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:53,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:57:59,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:01,496 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:58:01,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:58:05,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:10,718 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:15,719 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:16,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:58:16,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:58:18,676 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:58:21,677 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:26,719 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:31,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:58:31,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:58:32,719 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:37,719 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:43,719 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:46,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:58:46,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:58:48,680 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:58:49,681 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:58:54,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:00,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:01,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:59:01,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:59:06,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:12,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:16,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:59:16,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:59:18,680 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:59:18,681 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:23,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:28,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:31,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:59:31,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:59:34,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:39,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:44,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:46,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 12:59:46,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 12:59:48,682 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 12:59:50,683 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 12:59:55,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:00,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:01,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:00:01,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:00:06,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:12,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:16,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:00:16,497 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:00:18,683 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:00:18,684 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:23,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:29,721 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:31,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:00:31,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:00:32,388 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:00:32,389 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:00:32,389 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:00:32,428 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:00:32,559 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:00:33,583 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:00:35,429 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:40,722 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:45,722 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:46,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:00:46,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:00:48,688 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:00:51,689 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:00:56,722 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:01,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:01:01,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:01:02,722 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:07,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:13,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:16,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:01:16,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:01:18,687 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:01:19,688 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:24,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:30,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:31,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:01:31,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:01:36,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:42,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:46,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:01:46,498 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:01:48,689 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:01:48,690 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:53,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:01:59,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:01,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:02:01,499 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:02:05,723 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:10,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:16,498 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:02:16,499 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:02:16,671 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:18,689 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:02:21,690 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:26,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:31,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:02:31,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:02:32,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:37,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:43,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:46,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:02:46,499 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:02:48,693 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:02:49,694 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:54,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:02:59,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:01,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:03:01,499 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:03:05,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:10,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:15,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:16,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:03:16,499 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:03:18,692 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:03:21,693 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:26,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:31,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:03:31,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:03:32,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:37,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:43,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:46,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:03:46,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:03:48,694 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:03:49,695 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:54,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:03:59,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:01,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:04:01,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:04:05,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:10,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:15,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:16,499 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:04:16,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:04:18,695 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:04:21,696 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:26,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:31,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:04:31,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:04:32,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:37,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:42,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:46,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:04:46,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:04:48,696 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:04:48,698 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:53,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:04:58,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:01,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:05:01,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:05:04,727 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:07,840 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:05:07,842 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:05:07,843 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:05:07,854 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:05:08,081 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:05:09,105 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:05:09,855 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:10,117 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:05:15,791 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:16,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:05:16,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:05:18,698 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:05:21,700 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:26,791 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:31,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:05:31,500 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:05:32,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:37,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:43,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:46,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:05:46,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:05:48,700 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:05:49,700 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:05:54,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:00,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:01,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:06:01,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:06:06,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:11,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:16,500 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:06:16,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:06:17,792 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:18,701 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:06:22,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:27,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:31,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:06:31,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:06:33,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:38,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:43,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:46,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:06:46,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:06:48,706 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:06:49,707 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:54,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:06:59,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:01,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:07:01,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:07:05,793 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:10,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:16,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:07:16,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:07:16,674 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:18,704 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:07:21,705 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:26,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:31,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:07:31,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:07:31,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:36,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:42,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:46,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:07:46,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:07:48,707 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:07:48,707 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:53,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:07:58,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:01,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:08:01,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:08:04,794 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:09,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:14,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:16,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:08:16,501 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:08:18,707 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:08:20,708 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:25,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:30,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:31,501 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:08:31,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:08:36,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:41,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:46,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:08:46,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:08:46,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:48,708 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:08:51,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:08:56,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:01,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:09:01,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:09:02,795 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:07,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:12,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:16,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:09:16,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:09:18,714 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:09:18,716 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:23,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:29,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:31,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:09:31,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:09:35,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:40,796 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:43,900 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:09:43,900 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:09:43,900 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:09:43,917 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:09:44,076 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:09:45,095 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:09:46,107 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:46,107 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:09:46,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:09:46,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:09:48,711 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:09:51,712 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:09:56,797 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:01,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:10:01,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:10:01,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:07,798 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:12,798 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:16,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:10:16,502 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:10:18,713 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:10:18,715 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:23,798 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:28,798 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:31,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:10:31,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:10:34,798 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:39,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:44,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:46,502 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:10:46,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:10:48,716 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:10:50,717 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:10:55,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:00,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:01,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:11:01,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:11:06,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:11,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:16,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:11:16,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:11:17,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:18,715 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:11:23,799 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:28,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:31,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:11:31,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:11:34,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:39,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:45,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:46,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:11:46,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:11:48,718 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:11:51,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:11:56,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:01,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:12:01,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:12:02,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:07,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:13,800 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:16,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:12:16,503 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:12:18,718 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:12:19,720 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:24,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:30,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:31,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:12:31,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:12:36,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:41,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:46,503 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:12:46,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:12:47,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:48,720 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:12:52,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:12:57,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:01,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:13:01,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:13:03,801 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:08,802 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:13,802 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:16,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:13:16,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:13:18,724 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:13:19,725 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:24,802 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:29,802 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:31,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:13:31,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:13:35,802 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:40,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:45,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:46,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:13:46,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:13:48,723 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:13:51,724 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:13:56,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:01,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:14:01,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:14:02,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:07,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:13,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:16,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:14:16,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:14:18,725 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:14:19,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:21,110 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:14:21,111 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:14:21,111 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:14:21,122 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:14:21,898 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:14:22,910 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:14:24,803 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:29,804 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:31,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:14:31,504 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:14:35,804 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:40,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:46,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:14:46,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:14:46,678 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:48,725 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:14:51,726 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:14:56,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:01,504 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:15:01,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:15:02,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:07,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:12,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:16,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:15:16,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:15:18,737 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:15:18,738 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:23,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:28,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:31,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:15:31,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:15:34,805 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:39,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:44,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:46,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:15:46,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:15:48,728 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:15:50,729 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:15:55,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:00,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:01,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:16:01,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:16:06,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:11,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:16,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:16:16,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:16:17,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:18,730 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:16:22,806 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:27,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:31,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:16:31,505 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:16:33,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:38,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:43,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:46,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:16:46,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:16:48,732 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:16:49,733 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:54,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:16:59,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:01,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:17:01,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:17:04,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:09,807 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:14,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:16,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:17:16,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:17:18,741 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:17:20,742 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:25,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:31,505 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:17:31,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:17:31,679 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:36,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:41,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:46,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:17:46,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:17:47,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:48,734 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:17:52,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:17:58,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:01,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:18:01,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:18:04,808 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:09,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:14,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:16,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:18:16,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:18:18,737 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:18:20,738 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:25,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:30,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:31,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:18:31,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:18:36,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:41,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:46,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:18:46,506 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:18:46,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:48,737 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:18:51,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:18:56,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:01,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:19:01,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:19:01,809 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:04,588 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:19:04,589 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:19:04,589 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:19:04,600 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:19:04,901 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:19:04,901 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:19:06,810 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:06,924 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:19:11,810 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:16,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:19:16,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:19:16,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:18,741 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:19:21,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:27,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:31,506 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:19:31,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:19:32,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:38,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:43,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:46,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:19:46,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:19:48,740 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:19:49,741 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:19:54,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:00,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:01,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:20:01,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:20:06,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:12,811 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:16,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:20:16,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:20:18,743 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:20:18,743 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:23,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:29,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:31,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:20:31,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:20:35,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:40,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:46,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:20:46,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:20:46,679 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:48,743 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:20:51,744 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:20:56,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:01,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:21:01,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:21:02,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:07,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:12,812 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:16,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:21:16,507 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:21:18,747 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:21:18,748 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:23,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:28,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:31,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:21:31,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:21:34,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:39,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:44,813 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:46,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:21:46,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:21:48,745 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:21:50,746 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:21:55,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:01,507 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:22:01,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:22:01,668 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:06,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:12,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:16,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:22:16,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:22:18,748 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:22:18,749 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:23,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:28,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:31,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:22:31,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:22:34,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:39,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:44,814 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:46,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:22:46,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:22:48,748 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:22:50,749 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:22:55,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:00,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:01,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:23:01,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:23:06,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:12,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:16,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:23:16,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:23:18,753 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:23:18,754 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:23,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:28,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:31,508 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:23:31,508 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:23:34,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:39,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:45,815 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:46,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:23:46,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:23:47,775 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: partial_history +2024-06-18 13:23:47,776 DEBUG SenderThread:458031 [sender.py:send():379] send: history +2024-06-18 13:23:47,776 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: summary_record +2024-06-18 13:23:47,791 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:23:48,689 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:23:48,751 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:23:49,701 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:23:50,717 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:23:51,752 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:23:56,816 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:01,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:24:01,509 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:24:01,816 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:06,816 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:11,817 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:16,511 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:24:16,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:24:16,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:18,753 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:24:21,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:27,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:31,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:24:31,509 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:24:33,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:38,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:43,943 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:46,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:24:46,509 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:24:48,756 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:24:49,757 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:54,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:24:58,696 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:24:59,288 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:24:59,288 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:24:59,288 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:24:59,288 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:24:59,289 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:24:59,289 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:24:59,290 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:25:00,651 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:25:00,651 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:25:00,651 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:25:00,654 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:25:00,655 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:01,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:25:01,509 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:25:05,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:10,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:15,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:16,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:25:16,509 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:25:21,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:23,444 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:25:23,444 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:25:23,444 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:25:23,444 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:25:23,445 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:25:23,445 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:25:23,445 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:25:23,445 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:25:23,446 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:25:25,036 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:25:26,944 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:31,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:25:31,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:25:31,945 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:36,945 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:42,945 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:46,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:25:46,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:25:47,945 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:52,986 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:53,410 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:25:55,441 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:25:57,203 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:25:57,204 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:25:57,204 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:25:57,204 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:25:57,205 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:25:57,205 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:25:57,205 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:25:57,205 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:25:57,464 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:25:58,476 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:25:58,729 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:25:58,729 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:25:58,729 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:25:58,729 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:25:58,732 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:26:01,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:26:01,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:26:04,075 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:09,075 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:14,075 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:16,509 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:26:16,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:26:20,075 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:25,075 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:25,695 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:26:25,695 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:26:25,695 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:26:25,695 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:26:25,696 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:26:25,696 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:26:25,696 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:26:25,697 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:26:25,697 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:26:26,892 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:26:27,904 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:26:30,082 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:31,511 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:26:31,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:26:36,076 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:41,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:46,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:46,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:26:46,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:26:51,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:55,277 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:26:55,887 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:26:55,887 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:26:55,887 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:26:55,888 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:26:55,889 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:26:55,889 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:26:55,890 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:26:55,890 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:26:57,305 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:26:57,362 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:26:57,362 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:26:57,362 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:26:57,362 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:26:57,366 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:27:01,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:27:01,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:27:01,683 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:07,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:12,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:16,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:27:16,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:27:17,077 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:22,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:28,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:31,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:27:31,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:27:34,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:39,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:44,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:46,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:27:46,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:27:50,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:27:55,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:00,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:01,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:28:01,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:28:05,078 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:10,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:15,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:16,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:28:16,510 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:28:21,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:26,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:31,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:28:31,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:28:31,682 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:37,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:40,735 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:28:40,736 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:28:40,736 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:28:40,736 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:28:40,736 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:28:40,736 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:28:40,737 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:28:40,737 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:28:40,737 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:28:40,776 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:28:40,776 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:28:40,776 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:28:40,777 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:28:40,777 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:28:40,777 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:28:40,777 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:28:40,777 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:28:42,147 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:28:42,147 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:28:42,147 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:28:42,147 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:28:42,149 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:43,693 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:28:46,510 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:28:46,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:28:48,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:49,551 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:28:49,551 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:28:49,551 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:28:49,551 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:28:49,552 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:28:49,552 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:28:49,552 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:28:49,553 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:28:49,553 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:28:49,592 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:28:49,592 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:28:49,592 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:28:49,592 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:28:49,593 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:28:49,593 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:28:49,593 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:28:49,593 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:28:51,262 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:28:51,263 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:28:51,263 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:28:51,263 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:28:52,315 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: keepalive +2024-06-18 13:28:53,315 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:28:58,554 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:28:58,554 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:28:58,554 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:28:58,554 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:28:58,555 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:28:58,555 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:28:58,555 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:28:58,555 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:28:58,556 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:28:58,596 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:28:58,597 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:28:58,597 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:28:58,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:28:58,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:28:58,597 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:28:58,597 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:28:58,597 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:28:59,903 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:29:00,237 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:29:00,237 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:29:00,237 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:29:00,237 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:00,237 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:29:01,511 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:29:01,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:29:01,816 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:29:01,817 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:29:01,817 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:29:01,817 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:29:01,817 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:29:01,817 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:29:01,818 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:29:01,818 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:29:01,819 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:29:01,824 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:29:01,824 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:29:01,824 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:29:01,824 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:29:01,825 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:29:01,825 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:29:01,825 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:29:01,825 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:29:03,331 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:29:03,331 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:29:03,331 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:29:03,334 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:29:03,953 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:29:04,335 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:05,134 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: resume +2024-06-18 13:29:05,134 INFO HandlerThread:458031 [handler.py:handle_request_resume():715] starting system metrics thread +2024-06-18 13:29:05,134 INFO HandlerThread:458031 [system_monitor.py:start():194] Starting system monitor +2024-06-18 13:29:05,135 INFO SystemMonitor:458031 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-06-18 13:29:05,135 INFO SystemMonitor:458031 [interfaces.py:start():188] Started cpu monitoring +2024-06-18 13:29:05,135 INFO SystemMonitor:458031 [interfaces.py:start():188] Started disk monitoring +2024-06-18 13:29:05,135 INFO SystemMonitor:458031 [interfaces.py:start():188] Started gpu monitoring +2024-06-18 13:29:05,136 INFO SystemMonitor:458031 [interfaces.py:start():188] Started memory monitoring +2024-06-18 13:29:05,137 INFO SystemMonitor:458031 [interfaces.py:start():188] Started network monitoring +2024-06-18 13:29:05,137 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: pause +2024-06-18 13:29:05,138 INFO HandlerThread:458031 [handler.py:handle_request_pause():724] stopping system metrics thread +2024-06-18 13:29:05,138 INFO HandlerThread:458031 [system_monitor.py:finish():203] Stopping system monitor +2024-06-18 13:29:05,139 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined cpu monitor +2024-06-18 13:29:05,139 DEBUG SystemMonitor:458031 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-06-18 13:29:05,139 DEBUG SystemMonitor:458031 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-06-18 13:29:05,139 DEBUG SystemMonitor:458031 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-06-18 13:29:05,141 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined disk monitor +2024-06-18 13:29:06,843 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined gpu monitor +2024-06-18 13:29:06,844 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined memory monitor +2024-06-18 13:29:06,844 INFO HandlerThread:458031 [interfaces.py:finish():200] Joined network monitor +2024-06-18 13:29:06,844 DEBUG SenderThread:458031 [sender.py:send():379] send: stats +2024-06-18 13:29:10,079 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:15,080 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:16,511 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:29:16,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:29:21,080 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:26,080 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:31,080 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:31,511 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: stop_status +2024-06-18 13:29:31,511 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: stop_status +2024-06-18 13:29:33,224 DEBUG SenderThread:458031 [sender.py:send():379] send: exit +2024-06-18 13:29:33,224 INFO SenderThread:458031 [sender.py:send_exit():586] handling exit code: 0 +2024-06-18 13:29:33,224 INFO SenderThread:458031 [sender.py:send_exit():588] handling runtime: 3000 +2024-06-18 13:29:33,239 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:29:33,239 INFO SenderThread:458031 [sender.py:send_exit():594] send defer +2024-06-18 13:29:33,239 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,239 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 0 +2024-06-18 13:29:33,240 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 0 +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 1 +2024-06-18 13:29:33,240 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,240 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 1 +2024-06-18 13:29:33,240 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 1 +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 2 +2024-06-18 13:29:33,240 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,240 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 2 +2024-06-18 13:29:33,240 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 2 +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 3 +2024-06-18 13:29:33,240 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,240 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 3 +2024-06-18 13:29:33,240 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 3 +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 4 +2024-06-18 13:29:33,240 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,240 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 4 +2024-06-18 13:29:33,240 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,240 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 4 +2024-06-18 13:29:33,241 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 5 +2024-06-18 13:29:33,241 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,241 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 5 +2024-06-18 13:29:33,241 DEBUG SenderThread:458031 [sender.py:send():379] send: summary +2024-06-18 13:29:33,265 INFO SenderThread:458031 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-06-18 13:29:33,265 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,265 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 5 +2024-06-18 13:29:33,265 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 6 +2024-06-18 13:29:33,265 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,265 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 6 +2024-06-18 13:29:33,265 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,265 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 6 +2024-06-18 13:29:33,265 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 7 +2024-06-18 13:29:33,265 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: status_report +2024-06-18 13:29:33,265 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:33,266 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 7 +2024-06-18 13:29:33,266 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:33,266 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 7 +2024-06-18 13:29:33,342 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:29:34,224 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: poll_exit +2024-06-18 13:29:36,452 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 8 +2024-06-18 13:29:36,452 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: poll_exit +2024-06-18 13:29:36,452 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:36,452 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 8 +2024-06-18 13:29:36,453 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:36,453 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 8 +2024-06-18 13:29:36,453 INFO SenderThread:458031 [job_builder.py:build():440] Attempting to build job artifact +2024-06-18 13:29:36,453 INFO SenderThread:458031 [job_builder.py:_get_source_type():569] is repo sourced job +2024-06-18 13:29:36,453 INFO SenderThread:458031 [job_builder.py:_get_program_relpath():587] run is notebook based run +2024-06-18 13:29:36,484 INFO SenderThread:458031 [job_builder.py:build():545] adding wandb-job metadata file +2024-06-18 13:29:36,497 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 9 +2024-06-18 13:29:36,497 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:36,497 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 9 +2024-06-18 13:29:36,497 DEBUG SenderThread:458031 [sender.py:send():379] send: artifact +2024-06-18 13:29:37,225 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: poll_exit +2024-06-18 13:29:37,275 INFO wandb-upload_1:458031 [upload_job.py:push():88] Uploaded file /admin/home-ckadirt/.local/share/wandb/artifacts/staging/tmpkafmpiii +2024-06-18 13:29:37,285 INFO wandb-upload_2:458031 [upload_job.py:push():88] Uploaded file /tmp/tmpecquxngl/wandb-job.json +2024-06-18 13:29:37,352 INFO wandb-upload_0:458031 [upload_job.py:push():88] Uploaded file /admin/home-ckadirt/.local/share/wandb/artifacts/staging/tmphgilykdc +2024-06-18 13:29:37,392 INFO Thread-12 :458031 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:29:37,843 INFO SenderThread:458031 [sender.py:send_artifact():1530] sent artifact job-https___github.com_MedARC-AI_MindEyeV2.git_ckadirt_MindEyeV2_src_TrainCluster.ipynb - {'id': 'QXJ0aWZhY3Q6ODczNjc5', 'state': 'PENDING', 'artifactSequence': {'id': 'QXJ0aWZhY3RDb2xsZWN0aW9uOjQ2NzIy', 'latestArtifact': None}} +2024-06-18 13:29:37,843 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:37,843 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 9 +2024-06-18 13:29:37,843 INFO SenderThread:458031 [dir_watcher.py:finish():358] shutting down directory watcher +2024-06-18 13:29:38,405 INFO SenderThread:458031 [dir_watcher.py:finish():388] scan: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files +2024-06-18 13:29:38,406 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml config.yaml +2024-06-18 13:29:38,406 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/diff.patch diff.patch +2024-06-18 13:29:38,406 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json wandb-summary.json +2024-06-18 13:29:38,408 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log output.log +2024-06-18 13:29:38,408 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-metadata.json wandb-metadata.json +2024-06-18 13:29:38,410 INFO SenderThread:458031 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt requirements.txt +2024-06-18 13:29:38,411 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 10 +2024-06-18 13:29:38,411 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: poll_exit +2024-06-18 13:29:38,411 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:38,413 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 10 +2024-06-18 13:29:38,413 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:38,413 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 10 +2024-06-18 13:29:38,413 INFO SenderThread:458031 [file_pusher.py:finish():169] shutting down file pusher +2024-06-18 13:29:38,599 INFO wandb-upload_1:458031 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/config.yaml +2024-06-18 13:29:38,802 INFO wandb-upload_3:458031 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/requirements.txt +2024-06-18 13:29:38,839 INFO wandb-upload_0:458031 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/wandb-summary.json +2024-06-18 13:29:39,056 INFO wandb-upload_2:458031 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/files/output.log +2024-06-18 13:29:39,226 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: poll_exit +2024-06-18 13:29:39,226 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: poll_exit +2024-06-18 13:29:39,256 INFO Thread-11 (_thread_body):458031 [sender.py:transition_state():614] send defer: 11 +2024-06-18 13:29:39,257 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:39,257 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 11 +2024-06-18 13:29:39,257 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:39,257 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 11 +2024-06-18 13:29:39,257 INFO SenderThread:458031 [file_pusher.py:join():175] waiting for file pusher +2024-06-18 13:29:39,257 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 12 +2024-06-18 13:29:39,257 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:39,257 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 12 +2024-06-18 13:29:39,258 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:39,258 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 12 +2024-06-18 13:29:39,258 INFO SenderThread:458031 [file_stream.py:finish():601] file stream finish called +2024-06-18 13:29:39,469 INFO SenderThread:458031 [file_stream.py:finish():605] file stream finish is done +2024-06-18 13:29:39,469 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 13 +2024-06-18 13:29:39,469 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:39,469 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 13 +2024-06-18 13:29:39,469 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:39,469 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 13 +2024-06-18 13:29:39,469 INFO SenderThread:458031 [sender.py:transition_state():614] send defer: 14 +2024-06-18 13:29:39,470 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: defer +2024-06-18 13:29:39,470 INFO HandlerThread:458031 [handler.py:handle_request_defer():184] handle defer: 14 +2024-06-18 13:29:39,470 DEBUG SenderThread:458031 [sender.py:send():379] send: final +2024-06-18 13:29:39,470 DEBUG SenderThread:458031 [sender.py:send():379] send: footer +2024-06-18 13:29:39,470 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: defer +2024-06-18 13:29:39,470 INFO SenderThread:458031 [sender.py:send_request_defer():610] handle sender defer: 14 +2024-06-18 13:29:39,471 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: poll_exit +2024-06-18 13:29:39,471 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: poll_exit +2024-06-18 13:29:39,471 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: server_info +2024-06-18 13:29:39,471 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: server_info +2024-06-18 13:29:39,471 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: poll_exit +2024-06-18 13:29:39,473 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: get_summary +2024-06-18 13:29:39,473 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: sampled_history +2024-06-18 13:29:39,474 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: internal_messages +2024-06-18 13:29:39,543 DEBUG SenderThread:458031 [sender.py:send_request():406] send_request: poll_exit +2024-06-18 13:29:39,544 INFO MainThread:458031 [wandb_run.py:_footer_history_summary_info():4008] rendering history +2024-06-18 13:29:39,544 INFO MainThread:458031 [wandb_run.py:_footer_history_summary_info():4040] rendering summary +2024-06-18 13:29:39,544 INFO MainThread:458031 [wandb_run.py:_footer_sync_info():3967] logging synced files +2024-06-18 13:29:39,546 DEBUG HandlerThread:458031 [handler.py:handle_request():158] handle_request: shutdown +2024-06-18 13:29:39,546 INFO HandlerThread:458031 [handler.py:finish():882] shutting down handler +2024-06-18 13:29:40,474 INFO WriterThread:458031 [datastore.py:close():296] close: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/run-testing.wandb +2024-06-18 13:29:40,544 INFO SenderThread:458031 [sender.py:finish():1608] shutting down sender +2024-06-18 13:29:40,544 INFO SenderThread:458031 [file_pusher.py:finish():169] shutting down file pusher +2024-06-18 13:29:40,544 INFO SenderThread:458031 [file_pusher.py:join():175] waiting for file pusher diff --git a/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug.log b/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..b1c5b5fa09289e43983e213c3c215bc23be6a296 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug.log @@ -0,0 +1,69 @@ +2024-06-18 12:36:14,405 INFO MainThread:448378 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Configure stats pid to 448378 +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program': ''} +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Applying login settings: {'base_url': 'https://stability.wandb.io'} +2024-06-18 12:36:14,406 INFO MainThread:448378 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug.log +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_123614-testing/logs/debug-internal.log +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:init():560] calling init triggers +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'testing', 'global_batch_size': 8, 'batch_size': 8, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 486928065, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'} +2024-06-18 12:36:14,407 INFO MainThread:448378 [wandb_init.py:init():610] starting backend +2024-06-18 12:36:14,408 INFO MainThread:448378 [wandb_init.py:init():614] setting up manager +2024-06-18 12:36:14,417 INFO MainThread:448378 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-06-18 12:36:14,421 INFO MainThread:448378 [wandb_init.py:init():622] backend started and connected +2024-06-18 12:36:14,444 INFO MainThread:448378 [wandb_run.py:_label_probe_notebook():1334] probe notebook +2024-06-18 12:36:14,445 INFO MainThread:448378 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get' +2024-06-18 12:36:14,445 INFO MainThread:448378 [wandb_init.py:init():711] updated telemetry +2024-06-18 12:36:14,557 INFO MainThread:448378 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-06-18 12:36:15,149 INFO MainThread:448378 [wandb_run.py:_on_init():2402] communicating current version +2024-06-18 12:36:15,199 INFO MainThread:448378 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.2 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-06-18 12:36:15,200 INFO MainThread:448378 [wandb_init.py:init():795] starting run threads in backend +2024-06-18 12:36:16,480 INFO MainThread:448378 [wandb_run.py:_console_start():2380] atexit reg +2024-06-18 12:36:16,480 INFO MainThread:448378 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-06-18 12:36:16,480 INFO MainThread:448378 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-06-18 12:36:16,480 INFO MainThread:448378 [wandb_run.py:_redirect():2325] Redirects installed. +2024-06-18 12:36:16,484 INFO MainThread:448378 [wandb_init.py:init():838] run started, returning control to user process +2024-06-18 12:36:16,489 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 12:36:16,490 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 12:36:16,562 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 12:36:16,563 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 12:36:16,563 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 12:36:16,646 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 12:36:16,653 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 12:36:16,654 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 12:36:16,746 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 12:36:16,917 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 12:36:16,917 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 12:36:17,011 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 12:36:17,012 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 12:36:17,013 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 12:36:17,101 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:24:59,287 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:24:59,288 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:25:23,444 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:25:57,202 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:25:57,203 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:26:25,695 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:26:55,886 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:26:55,887 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:28:40,735 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:28:40,757 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:28:40,758 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:28:49,551 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:28:49,553 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:28:49,553 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:28:58,554 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:28:58,558 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:28:58,559 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:29:01,816 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:29:01,823 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:29:01,824 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 13:29:05,134 INFO MainThread:448378 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 13:29:05,136 INFO MainThread:448378 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster.ipynb +2024-06-18 13:29:05,136 INFO MainThread:448378 [wandb_init.py:_pause_backend():431] pausing backend diff --git a/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/config.yaml b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..dd9518a2dd54c8754e0e3844c55cb9a11100dd96 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +model_name: + desc: null + value: testing-tt2 +global_batch_size: + desc: null + value: 16 +batch_size: + desc: null + value: 16 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 40 +num_params: + desc: null + value: 486928065 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 3.0e-05 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 30000 +num_test: + desc: null + value: 3000 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: false +seed: + desc: null + value: 42 +distributed: + desc: null + value: false +num_devices: + desc: null + value: 1 +world_size: + desc: null + value: 1 +train_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar +test_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar +_wandb: + desc: null + value: + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: true + is_kaggle_kernel: false + start_time: 1718729436 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 2: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 13 + - 14 + - 16 + - 23 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 1 + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/diff.patch b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/diff.patch new file mode 100644 index 0000000000000000000000000000000000000000..239bcbde69be9a2d8d3a4090628d40d1ce83ed26 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/diff.patch @@ -0,0 +1,240 @@ +diff --git a/src/Train.ipynb b/src/Train.ipynb +index 91922c8..396549d 100644 +--- a/src/Train.ipynb ++++ b/src/Train.ipynb +@@ -99,7 +99,7 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "PID of this process = 3001293\n", ++ "PID of this process = 3520819\n", + "device: cuda\n", + "Distributed environment: DistributedType.NO\n", + "Num processes: 1\n", +@@ -1362,9 +1362,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { +diff --git a/src/accel.slurm b/src/accel.slurm +index 1c1dfbc..f0b347f 100644 +--- a/src/accel.slurm ++++ b/src/accel.slurm +@@ -1,7 +1,8 @@ + #!/bin/bash +-#SBATCH --account=topfmri +-#SBATCH --partition=a40x +-#SBATCH --job-name=eye ++#SBATCH --account=fmri ++#SBATCH --qos=normal ++#SBATCH --partition=p5 ++#SBATCH --job-name=eyeRR + #SBATCH --nodes=1 + #SBATCH --gres=gpu:1 + #SBATCH --time=48:00:00 # total run time limit (HH:MM:SS) +@@ -12,11 +13,11 @@ + #SBATCH --exclusive + + # Make sure you activate your fmri environment created from src/setup.sh +-cd /weka/proj-fmri/paulscotti/MindEyeV2/src +-source fmri/bin/activate ++cd /weka/proj-fmri/ckadirt/MindEyeV2/src ++source /admin/home-ckadirt/fmri/bin/activate + + # The following line converts your jupyter notebook into a python script runnable with Slurm +-jupyter nbconvert Train.ipynb --to python ++jupyter nbconvert TrainCluster-Copy2.ipynb --to python + + export NUM_GPUS=1 # Set to equal gres=gpu:#! + export BATCH_SIZE=21 # 21 for multisubject / 24 for singlesubject (orig. paper used 42 for multisubject / 24 for singlesubject) +@@ -26,16 +27,16 @@ export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") + export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +-export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) ++export COUNT_NODE=1 #$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + echo MASTER_ADDR=${MASTER_ADDR} + echo MASTER_PORT=${MASTER_PORT} + echo WORLD_SIZE=${COUNT_NODE} + + # multisubject pretraining +-model_name="multisubject_excludingsubj01_40sess" ++model_name="rr-test-top" + echo model_name=${model_name} +-accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log +- ++# accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT --mixed_precision=fp16 TrainCluster.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log ++python TrainCluster-Copy2.py --data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/cache --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log + # singlesubject finetuning + #model_name="finetuned_subj01_40sess" + #echo model_name=${model_name} +diff --git a/src/recon_inference.ipynb b/src/recon_inference.ipynb +index 10d7e27..0593e7e 100644 +--- a/src/recon_inference.ipynb ++++ b/src/recon_inference.ipynb +@@ -12,7 +12,6 @@ + "name": "stdout", + "output_type": "stream", + "text": [ +- "LOCAL RANK 0\n", + "device: cuda\n" + ] + } +@@ -60,7 +59,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 33, ++ "execution_count": 2, + "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8", + "metadata": { + "tags": [] +@@ -71,9 +70,7 @@ + "output_type": "stream", + "text": [ + "model_name: final_subj01_pretrained_40sess_24bs\n", +- "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n", +- "The autoreload extension is already loaded. To reload it, use:\n", +- " %reload_ext autoreload\n" ++ "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset --cache_dir=/weka/proj-medarc/shared/mindeyev2_dataset --model_name=final_subj01_pretrained_40sess_24bs --subj=1 --hidden_dim=4096 --n_blocks=4 --new_test\n" + ] + } + ], +@@ -99,7 +96,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 34, ++ "execution_count": 3, + "id": "49e5dae4-606d-4dc6-b420-df9e4c14737e", + "metadata": { + "tags": [] +@@ -157,7 +154,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 35, ++ "execution_count": 4, + "id": "64672583-9f00-46f5-8d4e-00e4c7068a1d", + "metadata": { + "tags": [] +@@ -221,7 +218,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 36, ++ "execution_count": 5, + "id": "a3cbeea8-e95b-48d9-9bc2-91af260c93d1", + "metadata": {}, + "outputs": [ +@@ -254,39 +251,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 38, ++ "execution_count": null, + "id": "3afc4858-b6a6-4a52-9303-b4a50ea5cc0b", + "metadata": {}, +- "outputs": [ +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "param counts:\n", +- "83,653,863 total\n", +- "0 trainable\n", +- "param counts:\n", +- "64,409,600 total\n", +- "64,409,600 trainable\n", +- "param counts:\n", +- "1,903,020,028 total\n", +- "1,903,020,028 trainable\n", +- "param counts:\n", +- "1,967,429,628 total\n", +- "1,967,429,628 trainable\n", +- "param counts:\n", +- "259,865,216 total\n", +- "259,865,200 trainable\n", +- "param counts:\n", +- "2,227,294,844 total\n", +- "2,227,294,828 trainable\n", +- "\n", +- "---loading /weka/proj-fmri/paulscotti/MindEye2_git/train_logs/final_subj01_pretrained_40sess_24bs/last.pth ckpt---\n", +- "\n", +- "ckpt loaded!\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n", + " arch=\"ViT-bigG-14\",\n", +@@ -393,7 +361,7 @@ + }, + { + "cell_type": "code", +- "execution_count": 30, ++ "execution_count": null, + "id": "295824db-ab3d-450c-90fb-f656e48994ba", + "metadata": { + "tags": [] +@@ -430,38 +398,10 @@ + }, + { + "cell_type": "code", +- "execution_count": 31, ++ "execution_count": null, + "id": "f726f617-39f5-49e2-8d0c-d11d27d01c30", + "metadata": {}, +- "outputs": [ +- { +- "name": "stderr", +- "output_type": "stream", +- "text": [ +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n", +- "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n" +- ] +- }, +- { +- "name": "stdout", +- "output_type": "stream", +- "text": [ +- "Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False\n", +- "Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", +- "vector_suffix torch.Size([1, 1024])\n" +- ] +- } +- ], ++ "outputs": [], + "source": [ + "# prep unCLIP\n", + "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n", +@@ -715,9 +655,9 @@ + ], + "metadata": { + "kernelspec": { +- "display_name": "mindeye", ++ "display_name": "Python 3 (ipykernel)", + "language": "python", +- "name": "mindeye" ++ "name": "python3" + }, + "language_info": { + "codemirror_mode": { diff --git a/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/output.log b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..c5aa76035bddefc0296ef30c5754ba2a34f3797e --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/files/output.log @@ -0,0 +1,19 @@ +1875 +testing-tt2 starting with epoch 0 / 150 + 0%| | 0/150 [00:00'} +2024-06-18 16:50:36,773 INFO MainThread:3353055 [wandb_setup.py:_flush():76] Applying login settings: {'base_url': 'https://stability.wandb.io'} +2024-06-18 16:50:36,773 INFO MainThread:3353055 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-06-18 16:50:36,774 INFO MainThread:3353055 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/logs/debug.log +2024-06-18 16:50:36,774 INFO MainThread:3353055 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/logs/debug-internal.log +2024-06-18 16:50:36,774 INFO MainThread:3353055 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks +2024-06-18 16:50:36,775 INFO MainThread:3353055 [wandb_init.py:init():560] calling init triggers +2024-06-18 16:50:36,775 INFO MainThread:3353055 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'testing-tt2', 'global_batch_size': 16, 'batch_size': 16, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 486928065, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 3e-05, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'} +2024-06-18 16:50:36,775 INFO MainThread:3353055 [wandb_init.py:init():610] starting backend +2024-06-18 16:50:36,775 INFO MainThread:3353055 [wandb_init.py:init():614] setting up manager +2024-06-18 16:50:36,796 INFO MainThread:3353055 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-06-18 16:50:36,800 INFO MainThread:3353055 [wandb_init.py:init():622] backend started and connected +2024-06-18 16:50:36,824 INFO MainThread:3353055 [wandb_run.py:_label_probe_notebook():1334] probe notebook +2024-06-18 16:50:36,825 INFO MainThread:3353055 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get' +2024-06-18 16:50:36,825 INFO MainThread:3353055 [wandb_init.py:init():711] updated telemetry +2024-06-18 16:50:36,896 INFO MainThread:3353055 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-06-18 16:50:37,496 INFO MainThread:3353055 [wandb_run.py:_on_init():2402] communicating current version +2024-06-18 16:50:37,558 INFO MainThread:3353055 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.2 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-06-18 16:50:37,558 INFO MainThread:3353055 [wandb_init.py:init():795] starting run threads in backend +2024-06-18 16:50:39,062 INFO MainThread:3353055 [wandb_run.py:_console_start():2380] atexit reg +2024-06-18 16:50:39,062 INFO MainThread:3353055 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-06-18 16:50:39,062 INFO MainThread:3353055 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-06-18 16:50:39,062 INFO MainThread:3353055 [wandb_run.py:_redirect():2325] Redirects installed. +2024-06-18 16:50:39,068 INFO MainThread:3353055 [wandb_init.py:init():838] run started, returning control to user process +2024-06-18 16:50:39,072 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:50:39,073 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 16:50:39,157 INFO MainThread:3353055 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 16:50:39,158 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:50:39,159 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 16:50:39,237 INFO MainThread:3353055 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 16:50:39,249 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:50:39,253 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 16:50:39,338 INFO MainThread:3353055 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 16:50:39,509 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:50:39,509 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 16:50:39,592 INFO MainThread:3353055 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 16:50:39,593 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:50:39,594 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend +2024-06-18 16:50:39,686 INFO MainThread:3353055 [wandb_init.py:_resume_backend():436] resuming backend +2024-06-18 16:59:29,490 INFO MainThread:3353055 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainCluster-Copy2.ipynb +2024-06-18 16:59:29,491 INFO MainThread:3353055 [wandb_init.py:_pause_backend():431] pausing backend diff --git a/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/run-testing-tt2.wandb b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/run-testing-tt2.wandb new file mode 100644 index 0000000000000000000000000000000000000000..7753d2d6817ba5e02598e849e2fc26bd8e795cf4 Binary files /dev/null and b/MindEyeV2/src/wandb/run-20240618_165036-testing-tt2/run-testing-tt2.wandb differ diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8b837ea92bb83362eb6541748da7bde5521515f7 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml @@ -0,0 +1,117 @@ +wandb_version: 1 + +model_name: + desc: null + value: semantic_cluster_1.0 +global_batch_size: + desc: null + value: '21' +batch_size: + desc: null + value: 21 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 40 +num_params: + desc: null + value: 746793265 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 3.0e-05 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 30000 +num_test: + desc: null + value: 3000 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: true +seed: + desc: null + value: 42 +distributed: + desc: null + value: false +num_devices: + desc: null + value: 1 +world_size: + desc: null + value: 1 +train_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar +test_url: + desc: null + value: /weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar +_wandb: + desc: null + value: + code_path: code/src/Untitled1.py + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1720536200 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 2: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 5 + - 13 + - 14 + - 16 + - 23 + - 62 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..df09c96a6d65a03b6f6a731114fd660068e2d432 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log @@ -0,0 +1,105 @@ + +semantic_cluster_1.0 starting with epoch 0 / 150 + 0%| | 0/150 [00:00 + labels = semantic_cluster[torch.Tensor(test_coco_in)[test_indices].long().tolist()] + ~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^ +IndexError: index is out of bounds for dimension with size 0 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..2347d0447f56dbb71ead5c400af9006582197c89 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt @@ -0,0 +1,214 @@ +Babel==2.15.0 +CoCa-pytorch==0.1.0 +GitPython==3.1.43 +Jinja2==3.1.4 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Pygments==2.18.0 +QtPy==2.4.1 +Send2Trash==1.8.3 +absl-py==2.1.0 +accelerate==0.24.1 +aiohttp==3.9.5 +aiosignal==1.3.1 +annotated-types==0.7.0 +antlr4-python3-runtime==4.9.3 +anyio==4.4.0 +argon2-cffi-bindings==21.2.0 +argon2-cffi==23.1.0 +arrow==1.3.0 +asttokens==2.4.1 +async-lru==2.0.4 +attrs==23.2.0 +beartype==0.18.5 +beautifulsoup4==4.12.3 +bleach==6.1.0 +braceexpand==0.1.7 +certifi==2024.6.2 +cffi==1.16.0 +charset-normalizer==3.3.2 +click==8.1.7 +clip-anytorch==2.6.0 +clip==1.0 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +dalle2-pytorch==1.15.6 +datasets==2.20.0 +debugpy==1.8.1 +decorator==5.1.1 +deepspeed==0.13.1 +defusedxml==0.7.1 +diffusers==0.23.0 +dill==0.3.8 +docker-pycreds==0.4.0 +einops==0.8.0 +einx==0.3.0 +ema-pytorch==0.5.0 +embedding-reader==1.7.0 +evaluate==0.4.1 +executing==2.0.1 +fastjsonschema==2.20.0 +filelock==3.15.1 +fonttools==4.53.0 +fqdn==1.5.1 +frozendict==2.4.4 +frozenlist==1.4.1 +fsspec==2024.5.0 +ftfy==6.2.0 +gitdb==4.0.11 +h11==0.14.0 +h5py==3.10.0 +hjson==3.1.0 +httpcore==1.0.5 +httpx==0.27.0 +huggingface-hub==0.23.4 +idna==3.7 +imageio==2.34.1 +importlib_metadata==7.1.0 +ipykernel==6.29.4 +ipython==8.25.0 +ipywidgets==8.1.3 +isoduration==20.11.0 +jedi==0.19.1 +joblib==1.4.2 +json5==0.9.25 +jsonpointer==3.0.0 +jsonschema-specifications==2023.12.1 +jsonschema==4.22.0 +jupyter-console==6.6.3 +jupyter-events==0.10.0 +jupyter-lsp==2.2.5 +jupyter==1.0.0 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +jupyter_server==2.14.1 +jupyter_server_terminals==0.5.3 +jupyterlab==4.2.2 +jupyterlab_nvdashboard==0.11.0 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.27.2 +jupyterlab_widgets==3.0.11 +kiwisolver==1.4.5 +kornia==0.7.1 +lazy_loader==0.4 +lightning-utilities==0.11.2 +matplotlib-inline==0.1.7 +matplotlib==3.8.2 +mistune==3.0.2 +mpmath==1.3.0 +multidict==6.0.5 +multiprocess==0.70.16 +nbclient==0.10.0 +nbconvert==7.16.4 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.3 +ninja==1.11.1.1 +nltk==3.8.1 +notebook==7.2.1 +notebook_shim==0.2.4 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.18.1 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +omegaconf==2.3.0 +open-clip-torch==2.24.0 +overrides==7.7.0 +packaging==24.1 +pandas==2.2.0 +pandocfilters==1.5.1 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.3.0 +pip==24.1.1 +platformdirs==4.2.2 +prometheus_client==0.20.0 +prompt_toolkit==3.0.47 +protobuf==5.27.1 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +pyarrow-hotfix==0.6 +pyarrow==15.0.2 +pycparser==2.22 +pydantic==2.7.4 +pydantic_core==2.18.4 +pynvml==11.5.0 +pyparsing==3.1.2 +python-dateutil==2.9.0.post0 +python-json-logger==2.0.7 +pytorch-lightning==2.0.1 +pytorch-warmup==0.1.1 +pytz==2024.1 +pyzmq==26.0.3 +qtconsole==5.5.2 +referencing==0.35.1 +regex==2024.5.15 +requests==2.32.3 +resize-right==0.0.2 +responses==0.18.0 +rfc3339-validator==0.1.4 +rfc3986-validator==0.1.1 +rotary-embedding-torch==0.6.2 +rouge_score==0.1.2 +rpds-py==0.18.1 +safetensors==0.4.3 +scikit-image==0.22.0 +scikit-learn==1.5.0 +scipy==1.13.1 +sentence-transformers==2.5.1 +sentencepiece==0.2.0 +sentry-sdk==2.5.1 +setproctitle==1.3.3 +setuptools==65.5.0 +six==1.16.0 +smmap==5.0.1 +sniffio==1.3.1 +soupsieve==2.5 +stack-data==0.6.3 +sympy==1.12.1 +terminado==0.18.1 +threadpoolctl==3.5.0 +tifffile==2024.5.22 +timm==1.0.3 +tinycss2==1.3.0 +tokenizers==0.15.2 +torch-fidelity==0.3.0 +torch==2.1.0 +torchmetrics==1.3.0.post0 +torchvision==0.16.0 +tornado==6.4.1 +tqdm==4.66.4 +traitlets==5.14.3 +transformers==4.37.2 +triton==2.1.0 +types-python-dateutil==2.9.0.20240316 +typing_extensions==4.12.2 +tzdata==2024.1 +umap==0.1.1 +uri-template==1.3.0 +urllib3==2.2.1 +vector-quantize-pytorch==1.14.24 +wandb==0.17.1 +wcwidth==0.2.13 +webcolors==24.6.0 +webdataset==0.2.73 +webencodings==0.5.1 +websocket-client==1.8.0 +widgetsnbextension==4.0.11 +x-clip==0.14.4 +xformers==0.0.22.post7 +xxhash==3.4.1 +yarl==1.9.4 +zipp==3.19.2 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..eae1ca832a821a2b902254257775cb05b3cea5d5 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/loss": 48.73381699099928, "test/loss": 43.27317428588867, "train/lr": 1.5544540848226823e-05, "train/num_steps": 1428, "test/num_steps": 1, "train/fwd_pct_correct": 0.26997466387190655, "train/bwd_pct_correct": 0.22905829625532909, "test/test_fwd_pct_correct": 0.6066666841506958, "test/test_bwd_pct_correct": 0.3866666853427887, "train/loss_clip_total": 2.3916878400146127, "train/loss_blurry_total": 0.0, "train/loss_blurry_cont_total": 0.0, "test/loss_clip_total": 2.478389024734497, "train/blurry_pixcorr": 0.0, "test/blurry_pixcorr": 0.0, "train/recon_cossim": 0.022250258135235238, "test/recon_cossim": 0.0, "train/recon_mse": 1.4354427751539802, "test/recon_mse": 0.0, "train/loss_prior": 1.4354427751539802, "test/loss_prior": 1.267486810684204, "train/loss_RR": 3.2788458580062505, "test/loss_RR": 2.7701785564422607, "train/class_precisions_1": 19.024276377217213, "test/class_precisions_1": 33.33333333333333, "train/class_precisions_5": 46.1184473789516, "test/class_precisions_5": 64.0, "train/class_precisions_10": 62.114845938375126, "test/class_precisions_10": 74.66666666666667, "_timestamp": 1720536670.7532716, "_runtime": 924.713892698288, "_step": 0, "_wandb": {"runtime": 1326}} \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug-internal.log b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..b05a3ae2df14b81e14bdf3d96f8b2000e9345d54 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug-internal.log @@ -0,0 +1,1043 @@ +2024-07-09 14:43:20,887 INFO StreamThr :1172003 [internal.py:wandb_internal():85] W&B internal server running at pid: 1172003, started at: 2024-07-09 14:43:20.883102 +2024-07-09 14:43:20,888 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status +2024-07-09 14:43:20,923 INFO WriterThread:1172003 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/run-semantic_cluster_1.0.wandb +2024-07-09 14:43:20,928 DEBUG SenderThread:1172003 [sender.py:send():379] send: header +2024-07-09 14:43:21,008 DEBUG SenderThread:1172003 [sender.py:send():379] send: run +2024-07-09 14:43:21,023 INFO SenderThread:1172003 [sender.py:_setup_resume():749] checking resume status for None/mindeye_semantic_cluster_0.2/semantic_cluster_1.0 +2024-07-09 14:43:21,472 INFO SenderThread:1172003 [sender.py:_setup_resume():829] configured resuming with: ResumeState(resumed=True,step=0,history=0,events=15,output=56,runtime=454.852238,wandb_runtime=454,summary={'_wandb': {'runtime': 454}},config={'seed': {'desc': None, 'value': 42}, '_wandb': {'desc': None, 'value': {'t': {'1': [1, 9, 11, 41, 49, 55, 63, 71, 79, 83, 103], '2': [1, 9, 11, 41, 49, 55, 63, 71, 79, 83, 103], '3': [13, 14, 16, 23], '4': '3.11.9', '5': '0.17.1', '6': '4.37.2', '8': [5], '13': 'linux-x86_64'}, 'code_path': 'code/src/Untitled1.py', 'framework': 'huggingface', 'start_time': 1720535458, 'cli_version': '0.17.1', 'is_jupyter_run': False, 'python_version': '3.11.9', 'is_kaggle_kernel': False, 'huggingface_version': '4.37.2'}}, 'max_lr': {'desc': None, 'value': 3e-05}, 'num_test': {'desc': None, 'value': 3000}, 'test_url': {'desc': None, 'value': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'}, 'mixup_pct': {'desc': None, 'value': 0.33}, 'train_url': {'desc': None, 'value': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar'}, 'batch_size': {'desc': None, 'value': 21}, 'blur_scale': {'desc': None, 'value': 0.5}, 'clip_scale': {'desc': None, 'value': 1}, 'model_name': {'desc': None, 'value': 'semantic_cluster_1.0'}, 'num_epochs': {'desc': None, 'value': 150}, 'num_params': {'desc': None, 'value': 746793265}, 'world_size': {'desc': None, 'value': 1}, 'ckpt_saving': {'desc': None, 'value': True}, 'distributed': {'desc': None, 'value': False}, 'num_devices': {'desc': None, 'value': 1}, 'prior_scale': {'desc': None, 'value': 30}, 'num_sessions': {'desc': None, 'value': 40}, 'ckpt_interval': {'desc': None, 'value': 999}, 'use_image_aug': {'desc': None, 'value': False}, 'global_batch_size': {'desc': None, 'value': '21'}, 'num_samples_per_epoch': {'desc': None, 'value': 30000}},tags=[]) +2024-07-09 14:43:21,667 INFO SenderThread:1172003 [dir_watcher.py:__init__():211] watching files in: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files +2024-07-09 14:43:21,667 INFO SenderThread:1172003 [sender.py:_start_run_threads():1188] run started: semantic_cluster_1.0 with start time 1720535746.039379 +2024-07-09 14:43:21,668 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: summary_record +2024-07-09 14:43:21,675 INFO SenderThread:1172003 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-09 14:43:21,703 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: check_version +2024-07-09 14:43:21,703 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: check_version +2024-07-09 14:43:21,781 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: run_start +2024-07-09 14:43:21,850 DEBUG HandlerThread:1172003 [system_info.py:__init__():26] System info init +2024-07-09 14:43:21,850 DEBUG HandlerThread:1172003 [system_info.py:__init__():41] System info init done +2024-07-09 14:43:21,850 INFO HandlerThread:1172003 [system_monitor.py:start():194] Starting system monitor +2024-07-09 14:43:21,850 INFO SystemMonitor:1172003 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-07-09 14:43:21,851 INFO SystemMonitor:1172003 [interfaces.py:start():188] Started cpu monitoring +2024-07-09 14:43:21,851 INFO SystemMonitor:1172003 [interfaces.py:start():188] Started disk monitoring +2024-07-09 14:43:21,851 INFO SystemMonitor:1172003 [interfaces.py:start():188] Started gpu monitoring +2024-07-09 14:43:21,852 INFO SystemMonitor:1172003 [interfaces.py:start():188] Started memory monitoring +2024-07-09 14:43:21,852 INFO SystemMonitor:1172003 [interfaces.py:start():188] Started network monitoring +2024-07-09 14:43:22,443 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: python_packages +2024-07-09 14:43:22,443 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: python_packages +2024-07-09 14:43:22,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:43:22,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:22,465 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:43:22,641 DEBUG SenderThread:1172003 [sender.py:send():379] send: telemetry +2024-07-09 14:43:22,680 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json +2024-07-09 14:43:22,680 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt +2024-07-09 14:43:23,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:23,696 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:43:24,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:25,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:25,729 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:43:25,898 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:26,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:27,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:28,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:29,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:30,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:31,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:31,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:32,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:33,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:34,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:35,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:36,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:37,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:43:37,444 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:43:37,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:37,620 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:38,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:39,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:40,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:41,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:42,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:43,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:43,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:44,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:45,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:46,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:47,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:48,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:49,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:49,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:50,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:51,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:52,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:43:52,444 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:43:52,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:53,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:54,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:54,625 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:43:55,156 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml +2024-07-09 14:43:55,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:56,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:57,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:58,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:43:59,451 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:00,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:00,451 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:01,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:02,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:03,451 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:04,451 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:05,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:06,449 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:06,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:07,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:44:07,444 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:44:07,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:08,451 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:09,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:10,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:11,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:11,623 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:12,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:13,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:14,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:15,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:16,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:17,450 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:17,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:18,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:19,453 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:20,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:21,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:21,852 DEBUG SystemMonitor:1172003 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-07-09 14:44:21,854 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:44:22,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:44:22,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:44:22,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:22,622 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:23,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:24,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:25,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:26,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:27,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:28,453 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:28,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:29,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:30,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:31,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:32,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:33,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:34,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:34,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:35,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:36,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:37,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:44:37,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:44:37,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:38,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:39,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:40,120 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:40,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:41,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:42,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:43,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:44,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:45,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:45,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:46,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:47,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:48,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:49,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:50,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:51,452 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:51,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:51,857 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:44:52,444 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:44:52,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:44:52,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:53,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:54,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:55,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:56,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:56,621 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:44:57,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:58,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:44:59,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:00,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:01,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:02,067 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:02,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:03,242 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:03,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:04,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:05,275 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:05,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:06,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:07,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:45:07,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:45:07,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:07,622 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:08,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:09,331 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:09,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:10,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:11,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:12,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:13,453 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:13,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:14,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:15,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:16,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:17,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:18,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:19,453 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:19,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:20,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:21,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:21,858 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:45:22,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:45:22,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:45:22,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:23,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:23,535 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:24,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:24,623 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:25,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:26,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:27,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:28,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:29,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:29,612 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:30,114 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:30,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:31,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:31,637 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:32,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:33,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:34,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:35,453 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:35,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:36,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:37,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:45:37,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:45:37,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:38,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:39,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:40,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:41,154 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:41,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:41,772 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:42,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:43,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:44,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:45,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:46,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:46,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:47,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:48,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:49,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:50,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:50,888 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:51,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:51,519 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:51,862 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:45:52,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:45:52,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:45:52,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:53,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:54,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:54,951 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:45:55,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:56,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:56,558 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:45:57,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:58,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:45:59,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:00,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:01,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:02,454 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:02,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:03,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:04,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:05,123 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:05,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:06,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:07,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:46:07,445 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:46:07,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:07,623 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:08,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:09,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:10,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:11,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:12,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:13,257 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:13,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:14,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:15,281 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:15,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:16,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:17,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:18,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:18,862 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:19,336 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:19,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:20,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:21,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:21,861 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:46:22,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:46:22,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:46:22,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:23,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:24,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:24,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:25,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:26,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:27,455 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:27,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:28,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:29,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:30,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:30,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:31,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:32,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:33,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:34,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:35,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:35,577 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:35,691 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:36,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:37,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:46:37,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:46:37,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:38,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:39,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:40,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:41,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:41,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:42,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:43,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:44,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:45,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:46,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:47,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:47,471 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:48,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:49,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:50,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:51,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:51,864 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:46:52,445 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:46:52,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:46:52,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:52,549 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:53,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:54,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:55,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:56,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:57,472 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:57,872 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:46:58,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:46:58,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:46:59,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:00,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:00,910 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:01,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:02,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:02,937 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:03,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:03,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:04,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:04,969 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:05,473 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:06,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:07,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:47:07,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:47:07,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:08,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:08,623 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:09,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:10,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:11,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:12,474 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:13,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:14,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:14,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:15,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:16,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:17,147 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:17,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:18,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:19,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:19,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:20,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:21,206 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:21,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:21,874 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:47:22,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:47:22,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:47:22,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:23,240 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:23,475 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:24,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:24,623 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:25,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:26,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:27,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:28,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:29,326 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:29,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:29,998 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:30,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:31,352 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:31,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:32,476 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:33,378 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:33,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:34,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:35,266 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:35,403 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:35,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:36,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:37,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:47:37,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:47:37,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:38,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:39,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:40,477 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:40,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:41,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:42,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:43,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:43,546 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:44,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:45,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:45,572 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:47:46,057 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:46,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:47,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:48,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:49,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:50,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:51,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:51,478 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:51,867 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:47:52,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:47:52,446 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:47:52,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:53,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:54,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:55,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:56,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:56,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:47:57,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:58,479 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:47:59,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:00,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:01,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:02,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:02,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:03,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:04,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:05,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:06,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:07,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:48:07,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:48:07,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:08,142 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:08,480 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:09,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:10,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:10,911 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:11,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:12,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:13,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:13,835 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:14,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:14,978 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:15,481 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:16,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:17,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:18,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:19,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:19,610 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:20,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:21,062 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:21,482 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:21,869 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:48:22,446 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:48:22,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:48:22,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:23,087 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:23,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:24,483 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:24,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:25,483 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:26,483 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:27,139 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:27,502 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:28,483 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:29,165 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:29,483 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:30,330 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:30,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:31,191 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:31,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:32,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:33,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:34,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:35,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:35,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:36,484 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:37,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:48:37,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:48:37,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:38,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:39,301 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:39,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:40,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:40,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:41,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:42,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:43,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:44,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:45,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:46,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:46,485 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:47,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:48,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:49,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:50,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:51,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:51,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:51,870 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:48:52,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:48:52,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:48:52,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:53,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:53,500 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:48:54,486 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:55,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:56,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:56,625 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:48:57,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:58,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:59,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:48:59,580 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:00,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:01,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:01,796 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:02,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:03,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:03,645 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:04,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:05,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:06,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:07,198 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:07,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:49:07,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:49:07,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:07,707 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:08,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:09,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:10,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:11,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:12,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:12,488 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:13,489 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:14,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:15,489 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:16,489 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:17,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:17,489 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:17,841 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:18,489 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:19,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:20,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:21,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:21,872 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:49:21,892 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:22,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:49:22,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:49:22,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:22,624 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:23,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:24,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:25,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:26,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:27,490 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:28,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:28,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:29,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:30,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:31,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:32,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:33,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:34,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:34,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:35,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:36,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:37,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:49:37,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:49:37,491 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:38,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:39,154 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:39,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:39,625 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:40,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:41,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:42,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:43,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:44,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:45,046 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:45,243 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:45,492 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:46,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:47,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:48,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:49,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:50,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:50,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:51,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:51,873 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:49:52,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:49:52,447 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:49:52,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:53,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:54,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:55,383 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:49:55,493 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:56,358 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:49:56,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:57,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:58,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:49:59,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:00,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:01,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:01,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:02,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:03,494 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:04,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:05,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:05,525 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:50:06,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:06,723 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:07,447 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:50:07,448 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:50:07,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:08,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:09,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:10,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:11,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:12,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:12,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:13,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:13,635 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:50:14,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:15,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:16,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:17,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:17,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:18,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:19,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:20,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:21,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:21,876 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:50:22,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:50:22,448 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:50:22,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:23,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:23,637 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:24,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:25,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:26,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:27,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:28,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:29,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:29,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:30,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:31,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:32,498 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:33,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:34,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:35,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:35,500 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:36,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:37,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:50:37,448 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:50:37,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:38,499 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:39,500 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:40,500 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:40,626 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:41,506 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:42,506 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:43,506 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:44,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:45,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:46,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:46,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:47,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:48,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:49,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:50,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:51,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:51,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:51,881 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:50:52,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:50:52,448 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:50:52,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:53,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:54,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:55,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:56,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:56,626 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:50:57,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:58,508 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:50:59,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:00,509 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:01,509 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:02,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:02,509 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:03,509 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:04,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:05,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:06,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:07,448 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:51:07,449 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:51:07,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:07,627 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:08,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:09,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:10,510 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:10,794 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: partial_history +2024-07-09 14:51:10,796 DEBUG SenderThread:1172003 [sender.py:send():379] send: history +2024-07-09 14:51:10,796 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: summary_record +2024-07-09 14:51:10,805 INFO SenderThread:1172003 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-09 14:51:11,415 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json +2024-07-09 14:51:11,415 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:51:11,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:12,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:13,454 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:51:13,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:13,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:14,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:15,547 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:17,782 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:51:18,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:21,879 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:51:22,625 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:51:22,625 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:51:23,868 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:51:24,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:24,914 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:51:29,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:35,455 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:37,635 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:51:37,636 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:51:40,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:45,457 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:51,456 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:51:51,881 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:51:52,628 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:51:52,628 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:51:56,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:02,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:05,067 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:52:07,628 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:52:07,628 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:52:07,806 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:13,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:18,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:21,883 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:52:22,628 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:52:22,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:52:23,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:25,395 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:52:28,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:33,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:37,628 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:52:37,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:52:39,458 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:41,630 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:52:44,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:49,567 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:52:49,742 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:52:51,767 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:52:51,891 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:52:52,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:52:52,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:52:55,459 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:00,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:05,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:07,628 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:53:07,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:53:09,024 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:11,460 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:13,078 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:15,106 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:16,815 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:21,182 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:21,886 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:53:21,888 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:22,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:53:22,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:53:27,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:32,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:37,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:53:37,629 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:53:37,807 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:43,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:43,498 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:48,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:51,608 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:51,887 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:53:52,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:53:52,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:53:53,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:57,695 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:53:59,461 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:53:59,722 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:54:04,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:07,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:54:07,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:54:07,826 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:54:09,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:14,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:19,462 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:21,893 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:54:22,629 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:54:22,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:54:24,995 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:25,104 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:54:30,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:36,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:37,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:54:37,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:54:41,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:46,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:51,891 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:54:51,892 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:54:52,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:54:52,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:54:53,498 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:54:57,463 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:02,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:07,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:55:07,630 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:55:07,684 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:55:07,827 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:09,718 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:55:13,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:18,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:21,893 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:55:22,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:55:22,631 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:55:24,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:29,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:34,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:37,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:55:37,631 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:55:40,464 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:45,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:49,267 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:55:51,465 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:51,895 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:55:52,630 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:55:52,631 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:55:53,319 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:55:56,807 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:55:57,377 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:01,442 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:02,487 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:07,526 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:07,631 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:56:07,631 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:56:07,806 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:09,554 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:13,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:17,664 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:18,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:21,901 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:56:22,631 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:56:22,631 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:56:24,466 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:30,300 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:31,850 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:33,876 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:35,507 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:35,903 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:37,631 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:56:37,632 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:56:38,968 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:41,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:46,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:51,467 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:56:51,900 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:56:52,632 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:56:52,632 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:56:57,229 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:56:57,391 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:02,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:07,370 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:07,631 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:57:07,632 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:57:07,807 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:12,918 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:13,461 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:17,512 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:18,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:21,902 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:57:22,632 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:57:22,632 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:57:24,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:27,641 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:30,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:35,468 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:37,635 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:57:37,635 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:57:40,469 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:45,655 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:45,876 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:51,470 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:51,906 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:57:52,633 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: stop_status +2024-07-09 14:57:52,634 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: stop_status +2024-07-09 14:57:54,595 DEBUG SenderThread:1172003 [sender.py:send():379] send: exit +2024-07-09 14:57:54,595 INFO SenderThread:1172003 [sender.py:send_exit():586] handling exit code: 1 +2024-07-09 14:57:54,596 INFO SenderThread:1172003 [sender.py:send_exit():588] handling runtime: 1326 +2024-07-09 14:57:54,608 INFO SenderThread:1172003 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-09 14:57:54,609 INFO SenderThread:1172003 [sender.py:send_exit():594] send defer +2024-07-09 14:57:54,609 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:54,609 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 0 +2024-07-09 14:57:54,609 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:54,609 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 0 +2024-07-09 14:57:54,609 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 1 +2024-07-09 14:57:54,609 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:54,609 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 1 +2024-07-09 14:57:54,610 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:54,610 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 1 +2024-07-09 14:57:54,610 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 2 +2024-07-09 14:57:54,610 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:54,610 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 2 +2024-07-09 14:57:54,610 INFO HandlerThread:1172003 [system_monitor.py:finish():203] Stopping system monitor +2024-07-09 14:57:54,610 DEBUG SystemMonitor:1172003 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-07-09 14:57:54,611 DEBUG SystemMonitor:1172003 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-07-09 14:57:54,611 INFO HandlerThread:1172003 [interfaces.py:finish():200] Joined cpu monitor +2024-07-09 14:57:54,612 INFO HandlerThread:1172003 [interfaces.py:finish():200] Joined disk monitor +2024-07-09 14:57:55,004 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json +2024-07-09 14:57:56,017 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:56,494 INFO HandlerThread:1172003 [interfaces.py:finish():200] Joined gpu monitor +2024-07-09 14:57:56,494 INFO HandlerThread:1172003 [interfaces.py:finish():200] Joined memory monitor +2024-07-09 14:57:56,494 INFO HandlerThread:1172003 [interfaces.py:finish():200] Joined network monitor +2024-07-09 14:57:56,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:56,495 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,495 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 2 +2024-07-09 14:57:56,495 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 3 +2024-07-09 14:57:56,495 DEBUG SenderThread:1172003 [sender.py:send():379] send: stats +2024-07-09 14:57:56,495 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:56,496 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:56,496 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 3 +2024-07-09 14:57:56,496 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:56,496 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,497 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 3 +2024-07-09 14:57:56,497 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 4 +2024-07-09 14:57:56,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:56,497 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 4 +2024-07-09 14:57:56,497 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,497 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 4 +2024-07-09 14:57:56,497 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 5 +2024-07-09 14:57:56,497 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:56,497 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 5 +2024-07-09 14:57:56,497 DEBUG SenderThread:1172003 [sender.py:send():379] send: summary +2024-07-09 14:57:56,511 INFO SenderThread:1172003 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-09 14:57:56,511 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,511 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 5 +2024-07-09 14:57:56,511 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 6 +2024-07-09 14:57:56,511 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:56,511 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 6 +2024-07-09 14:57:56,512 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,512 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 6 +2024-07-09 14:57:56,512 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 7 +2024-07-09 14:57:56,512 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: status_report +2024-07-09 14:57:56,512 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:56,512 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 7 +2024-07-09 14:57:56,512 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:56,512 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 7 +2024-07-09 14:57:56,596 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:57,031 INFO Thread-12 :1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json +2024-07-09 14:57:57,436 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 8 +2024-07-09 14:57:57,436 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:57,436 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:57,436 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 8 +2024-07-09 14:57:57,437 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:57,437 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 8 +2024-07-09 14:57:57,437 INFO SenderThread:1172003 [job_builder.py:build():440] Attempting to build job artifact +2024-07-09 14:57:57,438 WARNING SenderThread:1172003 [job_builder.py:_log_if_verbose():274] Ensure read and write access to run files dir: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables +2024-07-09 14:57:57,438 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 9 +2024-07-09 14:57:57,438 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:57,438 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 9 +2024-07-09 14:57:57,439 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:57,439 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 9 +2024-07-09 14:57:57,439 INFO SenderThread:1172003 [dir_watcher.py:finish():358] shutting down directory watcher +2024-07-09 14:57:57,599 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:58,045 INFO SenderThread:1172003 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:58,045 INFO SenderThread:1172003 [dir_watcher.py:finish():388] scan: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files +2024-07-09 14:57:58,047 INFO SenderThread:1172003 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log output.log +2024-07-09 14:57:58,047 INFO SenderThread:1172003 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt requirements.txt +2024-07-09 14:57:58,047 INFO SenderThread:1172003 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml config.yaml +2024-07-09 14:57:58,049 INFO SenderThread:1172003 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json wandb-summary.json +2024-07-09 14:57:58,052 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 10 +2024-07-09 14:57:58,052 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:58,052 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:58,054 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 10 +2024-07-09 14:57:58,054 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:58,054 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 10 +2024-07-09 14:57:58,054 INFO SenderThread:1172003 [file_pusher.py:finish():169] shutting down file pusher +2024-07-09 14:57:58,485 INFO wandb-upload_0:1172003 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/output.log +2024-07-09 14:57:58,604 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:58,604 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:58,653 INFO wandb-upload_1:1172003 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/requirements.txt +2024-07-09 14:57:58,660 INFO wandb-upload_3:1172003 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/wandb-summary.json +2024-07-09 14:57:58,794 INFO wandb-upload_2:1172003 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/files/config.yaml +2024-07-09 14:57:58,994 INFO Thread-11 (_thread_body):1172003 [sender.py:transition_state():614] send defer: 11 +2024-07-09 14:57:58,995 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:58,995 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 11 +2024-07-09 14:57:58,995 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:58,995 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 11 +2024-07-09 14:57:58,995 INFO SenderThread:1172003 [file_pusher.py:join():175] waiting for file pusher +2024-07-09 14:57:58,995 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 12 +2024-07-09 14:57:58,995 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:58,996 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 12 +2024-07-09 14:57:58,996 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:58,996 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 12 +2024-07-09 14:57:58,996 INFO SenderThread:1172003 [file_stream.py:finish():601] file stream finish called +2024-07-09 14:57:59,072 INFO SenderThread:1172003 [file_stream.py:finish():605] file stream finish is done +2024-07-09 14:57:59,073 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 13 +2024-07-09 14:57:59,073 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:59,073 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 13 +2024-07-09 14:57:59,073 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:59,073 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 13 +2024-07-09 14:57:59,073 INFO SenderThread:1172003 [sender.py:transition_state():614] send defer: 14 +2024-07-09 14:57:59,073 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: defer +2024-07-09 14:57:59,073 DEBUG SenderThread:1172003 [sender.py:send():379] send: final +2024-07-09 14:57:59,073 INFO HandlerThread:1172003 [handler.py:handle_request_defer():184] handle defer: 14 +2024-07-09 14:57:59,073 DEBUG SenderThread:1172003 [sender.py:send():379] send: footer +2024-07-09 14:57:59,074 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: defer +2024-07-09 14:57:59,074 INFO SenderThread:1172003 [sender.py:send_request_defer():610] handle sender defer: 14 +2024-07-09 14:57:59,074 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:59,074 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:59,077 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: server_info +2024-07-09 14:57:59,077 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: server_info +2024-07-09 14:57:59,079 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-09 14:57:59,079 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: get_summary +2024-07-09 14:57:59,079 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: sampled_history +2024-07-09 14:57:59,080 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-09 14:57:59,152 DEBUG SenderThread:1172003 [sender.py:send_request():406] send_request: poll_exit +2024-07-09 14:57:59,152 INFO MainThread:1172003 [wandb_run.py:_footer_history_summary_info():4008] rendering history +2024-07-09 14:57:59,153 INFO MainThread:1172003 [wandb_run.py:_footer_history_summary_info():4040] rendering summary +2024-07-09 14:57:59,157 INFO MainThread:1172003 [wandb_run.py:_footer_sync_info():3967] logging synced files +2024-07-09 14:57:59,173 DEBUG HandlerThread:1172003 [handler.py:handle_request():158] handle_request: shutdown +2024-07-09 14:57:59,173 INFO HandlerThread:1172003 [handler.py:finish():882] shutting down handler +2024-07-09 14:58:00,079 INFO WriterThread:1172003 [datastore.py:close():296] close: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/run-semantic_cluster_1.0.wandb +2024-07-09 14:58:00,152 INFO SenderThread:1172003 [sender.py:finish():1608] shutting down sender +2024-07-09 14:58:00,152 INFO SenderThread:1172003 [file_pusher.py:finish():169] shutting down file pusher +2024-07-09 14:58:00,152 INFO SenderThread:1172003 [file_pusher.py:join():175] waiting for file pusher diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug.log b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..e5b5e5bf21e861894af7d862d4420ce75583bfc1 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug.log @@ -0,0 +1,30 @@ +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Configure stats pid to 1148993 +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': 'src/Untitled1.py', 'program_abspath': '/weka/proj-fmri/ckadirt/MindEyeV2/src/Untitled1.py', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/Untitled1.py'} +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Applying login settings: {'base_url': 'https://stability.wandb.io'} +2024-07-09 14:43:20,866 INFO MainThread:1148993 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-07-09 14:43:20,867 INFO MainThread:1148993 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug.log +2024-07-09 14:43:20,868 INFO MainThread:1148993 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/logs/debug-internal.log +2024-07-09 14:43:20,868 INFO MainThread:1148993 [wandb_init.py:init():560] calling init triggers +2024-07-09 14:43:20,868 INFO MainThread:1148993 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'semantic_cluster_1.0', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 746793265, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 3e-05, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/train/{0..39}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar'} +2024-07-09 14:43:20,868 INFO MainThread:1148993 [wandb_init.py:init():610] starting backend +2024-07-09 14:43:20,868 INFO MainThread:1148993 [wandb_init.py:init():614] setting up manager +2024-07-09 14:43:20,882 INFO MainThread:1148993 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-07-09 14:43:20,890 INFO MainThread:1148993 [wandb_init.py:init():622] backend started and connected +2024-07-09 14:43:20,923 INFO MainThread:1148993 [wandb_init.py:init():711] updated telemetry +2024-07-09 14:43:21,007 INFO MainThread:1148993 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-07-09 14:43:21,656 INFO MainThread:1148993 [wandb_init.py:init():787] run resumed +2024-07-09 14:43:21,702 INFO MainThread:1148993 [wandb_run.py:_on_init():2402] communicating current version +2024-07-09 14:43:21,757 INFO MainThread:1148993 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.4 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-07-09 14:43:21,757 INFO MainThread:1148993 [wandb_init.py:init():795] starting run threads in backend +2024-07-09 14:43:22,444 INFO MainThread:1148993 [wandb_run.py:_console_start():2380] atexit reg +2024-07-09 14:43:22,444 INFO MainThread:1148993 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-07-09 14:43:22,444 INFO MainThread:1148993 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-07-09 14:43:22,444 INFO MainThread:1148993 [wandb_run.py:_redirect():2325] Redirects installed. +2024-07-09 14:43:22,451 INFO MainThread:1148993 [wandb_init.py:init():838] run started, returning control to user process +2024-07-09 14:58:00,174 WARNING MsgRouterThr:1148993 [router.py:message_loop():77] message_loop has been closed diff --git a/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/run-semantic_cluster_1.0.wandb b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/run-semantic_cluster_1.0.wandb new file mode 100644 index 0000000000000000000000000000000000000000..75fefa0d6de71497af2dbc12efa1c1e8e13e8df2 Binary files /dev/null and b/MindEyeV2/src/wandb/run-20240709_144320-semantic_cluster_1.0/run-semantic_cluster_1.0.wandb differ diff --git a/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/config.yaml b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3bb651faec639615f5c7149b946ddaaf81984d71 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/config.yaml @@ -0,0 +1,111 @@ +wandb_version: 1 + +model_name: + desc: null + value: testingbold5000 +global_batch_size: + desc: null + value: 8 +batch_size: + desc: null + value: 8 +num_epochs: + desc: null + value: 150 +num_sessions: + desc: null + value: 14 +num_params: + desc: null + value: 2154632456 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: false +max_lr: + desc: null + value: 0.0003 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 5254 +num_test: + desc: null + value: 370 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: false +seed: + desc: null + value: 42 +distributed: + desc: null + value: false +num_devices: + desc: null + value: 1 +world_size: + desc: null + value: 1 +_wandb: + desc: null + value: + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: true + is_kaggle_kernel: false + start_time: 1721531262 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 2: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 5 + - 13 + - 14 + - 16 + - 23 + - 62 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 1 + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/output.log b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..746b1ca2a8191d7bb8b635cfa832d2f3c78fc0a5 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/files/output.log @@ -0,0 +1,19 @@ + + 0%| | 0/150 [00:00'} +2024-07-21 03:07:42,638 INFO MainThread:1284952 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-07-21 03:07:42,639 INFO MainThread:1284952 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/logs/debug.log +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/logs/debug-internal.log +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:init():560] calling init triggers +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'testingbold5000', 'global_batch_size': 8, 'batch_size': 8, 'num_epochs': 150, 'num_sessions': 14, 'num_params': 2154632456, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 5254, 'num_test': 370, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1} +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:init():610] starting backend +2024-07-21 03:07:42,640 INFO MainThread:1284952 [wandb_init.py:init():614] setting up manager +2024-07-21 03:07:42,651 INFO MainThread:1284952 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-07-21 03:07:42,653 INFO MainThread:1284952 [wandb_init.py:init():622] backend started and connected +2024-07-21 03:07:42,677 INFO MainThread:1284952 [wandb_run.py:_label_probe_notebook():1334] probe notebook +2024-07-21 03:07:42,679 INFO MainThread:1284952 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get' +2024-07-21 03:07:42,679 INFO MainThread:1284952 [wandb_init.py:init():711] updated telemetry +2024-07-21 03:07:42,746 INFO MainThread:1284952 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-07-21 03:07:43,342 INFO MainThread:1284952 [wandb_init.py:init():787] run resumed +2024-07-21 03:07:43,383 INFO MainThread:1284952 [wandb_run.py:_on_init():2402] communicating current version +2024-07-21 03:07:43,435 INFO MainThread:1284952 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.5 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-07-21 03:07:43,435 INFO MainThread:1284952 [wandb_init.py:init():795] starting run threads in backend +2024-07-21 03:07:43,899 INFO MainThread:1284952 [wandb_run.py:_console_start():2380] atexit reg +2024-07-21 03:07:43,899 INFO MainThread:1284952 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-07-21 03:07:43,900 INFO MainThread:1284952 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-07-21 03:07:43,900 INFO MainThread:1284952 [wandb_run.py:_redirect():2325] Redirects installed. +2024-07-21 03:07:43,902 INFO MainThread:1284952 [wandb_init.py:init():838] run started, returning control to user process +2024-07-21 03:07:43,907 INFO MainThread:1284952 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-07-21 03:07:43,908 INFO MainThread:1284952 [wandb_init.py:_pause_backend():431] pausing backend +2024-07-21 03:07:44,048 INFO MainThread:1284952 [wandb_init.py:_resume_backend():436] resuming backend +2024-07-21 03:07:44,050 INFO MainThread:1284952 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-07-21 03:07:44,051 INFO MainThread:1284952 [wandb_init.py:_pause_backend():431] pausing backend +2024-07-21 03:07:44,144 INFO MainThread:1284952 [wandb_init.py:_resume_backend():436] resuming backend +2024-07-21 03:07:44,146 INFO MainThread:1284952 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-07-21 03:07:44,147 INFO MainThread:1284952 [wandb_init.py:_pause_backend():431] pausing backend +2024-07-21 03:07:44,240 INFO MainThread:1284952 [wandb_init.py:_resume_backend():436] resuming backend +2024-07-21 03:07:45,827 INFO MainThread:1284952 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-07-21 03:07:45,827 INFO MainThread:1284952 [wandb_init.py:_pause_backend():431] pausing backend +2024-07-21 03:07:46,015 INFO MainThread:1284952 [wandb_init.py:_resume_backend():436] resuming backend +2024-07-21 03:38:48,259 INFO MainThread:1284952 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-07-21 03:38:48,260 INFO MainThread:1284952 [wandb_init.py:_pause_backend():431] pausing backend diff --git a/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/run-testingbold5000.wandb b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/run-testingbold5000.wandb new file mode 100644 index 0000000000000000000000000000000000000000..8fcc9853bd410b63e200fd122f78e440ad07b1a9 Binary files /dev/null and b/MindEyeV2/src/wandb/run-20240721_030742-testingbold5000/run-testingbold5000.wandb differ diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src/TrainBold5000.py b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src/TrainBold5000.py new file mode 100644 index 0000000000000000000000000000000000000000..064447cc96226a8bdf3c0f57b2f4d3c7ff907dac --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src/TrainBold5000.py @@ -0,0 +1,1022 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # Import packages & functions + +# In[1]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm +import webdataset as wds + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from accelerate import Accelerator + +# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main +sys.path.append('generative_models/') +import sgm +from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder # bigG embedder + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[2]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +data_type = torch.float16 # change depending on your mixed_precision +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# First use "accelerate config" in terminal and setup using deepspeed stage 2 with CPU offloading! +accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +if utils.is_interactive(): # set batch size here if using interactive notebook instead of submitting job + global_batch_size = batch_size = 8 +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + + +# In[3]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +num_devices = torch.cuda.device_count() +if num_devices==0 or not distributed: num_devices = 1 +num_workers = num_devices +print(accelerator.state) + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[4]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + model_name = "testingbold5000" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the 2nd cell block + jupyter_args = f"--data_path=/weka/proj-medarc/shared/bold5000/v1 \ + --cache_dir=/weka/proj-medarc/shared/cache \ + --model_name={model_name} \ + --no-multi_subject --subj=1 --batch_size={batch_size} --num_sessions=14 \ + --hidden_dim=4096 --clip_scale=1. \ + --no-blurry_recon --blur_scale=.5 \ + --use_prior --prior_scale=30 \ + --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --no-use_image_aug \ + --ckpt_interval=999 --no-ckpt_saving --wandb_log" + # --multisubject_ckpt=../train_logs/multisubject_subj01_1024_24bs_nolow + + print(jupyter_args) + jupyter_args = jupyter_args.split() + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[5]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default=os.getcwd(), + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--cache_dir", type=str, default=os.getcwd(), + help="Path to where misc. files downloaded from huggingface are stored. Defaults to current src directory.", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8], + help="Validate on which subject?", +) +parser.add_argument( + "--multisubject_ckpt", type=str, default=None, + help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.", +) +parser.add_argument( + "--num_sessions", type=int, default=1, + help="Number of training sessions to include", +) +parser.add_argument( + "--use_prior",action=argparse.BooleanOptionalAction,default=True, + help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)", +) +parser.add_argument( + "--batch_size", type=int, default=16, + help="Batch size can be increased by 10x if only training retreival submodule and not diffusion prior", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=.5, + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--prior_scale",type=float,default=30, + help="multiply diffusion prior loss by this", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=False, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=150, + help="number of epochs of training", +) +parser.add_argument( + "--multi_subject",action=argparse.BooleanOptionalAction,default=False, +) +parser.add_argument( + "--new_test",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--n_blocks",type=int,default=4, +) +parser.add_argument( + "--hidden_dim",type=int,default=1024, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +# seed all random functions +utils.seed_everything(seed) + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) + +if use_image_aug or blurry_recon: + import kornia + from kornia.augmentation.container import AugmentationSequential +if use_image_aug: + img_augment = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + +if multi_subject: + subj_list = np.arange(1,9) + subj_list = subj_list[subj_list != subj] +else: + subj_list = [subj] + +print("subj_list", subj_list, "num_sessions", num_sessions) + + +# # Prep data, models, and dataloaders + +# ### Creating wds dataloader, preload betas and all 73k possible images + +# In[6]: + + +def my_split_by_node(urls): return urls +num_voxels_list = [] + +n_trials_per_subject = [5254, 5254, 5254, 3108] + +if multi_subject: + nsessions_allsubj=np.array([15,15,15,9]) + num_samples_per_epoch = (750*40) // num_devices +else: + num_samples_per_epoch = n_trials_per_subject[subj_list[0]] // num_devices + +print("dividing batch size by subj_list, which will then be concatenated across subj during training...") +batch_size = batch_size // len(subj_list) + +num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list)) + +print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch) + + +# In[7]: + + +# load the data +images1 = torch.load('/weka/proj-medarc/shared/bold5000/v1/subj1/images_stimuli.pt') +voxels1 = torch.load('/weka/proj-medarc/shared/bold5000/v1/subj1/voxels.pt') + + +# In[8]: + + +"""train_data = {} +train_dl = {} +num_voxels = {} +voxels = {} +for s in subj_list: + print(f"Training with {num_sessions} sessions") + if multi_subject: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{nsessions_allsubj[s-1]-1}" + "}.tar" + else: + train_url = f"{data_path}/wds/subj0{s}/train/" + "{0.." + f"{num_sessions-1}" + "}.tar" + print(train_url) + + train_data[f'subj0{s}'] = wds.WebDataset(train_url,resampled=True,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) + train_dl[f'subj0{s}'] = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + + f = h5py.File(f'{data_path}/betas_all_subj0{s}_fp32_renorm.hdf5', 'r') + betas = f['betas'][:] + betas = torch.Tensor(betas).to("cpu").to(data_type) + num_voxels_list.append(betas[0].shape[-1]) + num_voxels[f'subj0{s}'] = betas[0].shape[-1] + voxels[f'subj0{s}'] = betas + print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}") + +print("Loaded all subj train dls and betas!\n") + +# Validate only on one subject +if multi_subject: + subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list +if not new_test: # using old test set from before full dataset released (used in original MindEye paper) + if subj==3: + num_test=2113 + elif subj==4: + num_test=1985 + elif subj==6: + num_test=2113 + elif subj==8: + num_test=1985 + else: + num_test=2770 + test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +elif new_test: # using larger test set from after full dataset released + if subj==3: + num_test=2371 + elif subj==4: + num_test=2188 + elif subj==6: + num_test=2371 + elif subj==8: + num_test=2188 + else: + num_test=3000 + test_url = f"{data_path}/wds/subj0{subj}/new_test/" + "0.tar" +print(test_url) +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=num_test, shuffle=False, drop_last=True, pin_memory=True) +print(f"Loaded test dl for subj{subj}!\n")""" + + +# In[9]: + + +"""# Load 73k NSD images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'] +print("Loaded all 73k possible NSD images to cpu!", images.shape)""" + + +# ## Load models + +# ### CLIP image embeddings model + +# In[10]: + + +clip_img_embedder = FrozenOpenCLIPImageEmbedder( + arch="ViT-bigG-14", + version="laion2b_s39b_b160k", + output_tokens=True, + only_tokens=True, +) +clip_img_embedder.to(device) + +clip_seq_dim = 256 +clip_emb_dim = 1664 + + +# ### SD VAE + +# In[11]: + + +if blurry_recon: + from diffusers import AutoencoderKL + autoenc = AutoencoderKL( + down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'], + up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'], + block_out_channels=[128, 256, 512, 512], + layers_per_block=2, + sample_size=256, + ) + ckpt = torch.load(f'{cache_dir}/sd_image_var_autoenc.pth') + autoenc.load_state_dict(ckpt) + + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + from autoencoder.convnext import ConvnextXL + cnx = ConvnextXL(f'{cache_dir}/convnext_xlarge_alpha0.75_fullckpt.pth') + cnx.requires_grad_(False) + cnx.eval() + cnx.to(device) + + mean = torch.tensor([0.485, 0.456, 0.406]).to(device).reshape(1,3,1,1) + std = torch.tensor([0.228, 0.224, 0.225]).to(device).reshape(1,3,1,1) + + blur_augs = AugmentationSequential( + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.8), + kornia.augmentation.RandomGrayscale(p=0.1), + kornia.augmentation.RandomSolarize(p=0.1), + kornia.augmentation.RandomResizedCrop((224,224), scale=(.9,.9), ratio=(1,1), p=1.0), + data_keys=["input"], + ) + + +# ### MindEye modules + +# In[12]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[13]: + + +num_voxels_list = [voxels1.shape[-1]] +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer to enable regularization + def __init__(self, input_sizes, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linears = torch.nn.ModuleList([ + torch.nn.Linear(input_size, out_features) for input_size in input_sizes + ]) + def forward(self, x, subj_idx): + out = self.linears[subj_idx](x[:,0]).unsqueeze(1) + return out + +model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +# test on subject 1 with fake data +b = torch.randn((2,1,num_voxels_list[0])) +print(b.shape, model.ridge(b,0).shape) + + +# In[14]: + + +from models import BrainNetwork +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, n_blocks=n_blocks, + clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, + blurry_recon=blurry_recon, clip_scale=clip_scale) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((2,1,hidden_dim)) +print("b.shape",b.shape) + +backbone_, clip_, blur_ = model.backbone(b) +print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape) + + +# ### Adding diffusion prior + unCLIP if use_prior=True + +# In[15]: + + +if use_prior: + from models import * + + # setup diffusion prior network + out_dim = clip_emb_dim + depth = 6 + dim_head = 52 + heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim + timesteps = 100 + + prior_network = PriorNetwork( + dim=out_dim, + depth=depth, + dim_head=dim_head, + heads=heads, + causal=False, + num_tokens = clip_seq_dim, + learned_query_mode="pos_emb" + ) + + model.diffusion_prior = BrainDiffusionPrior( + net=prior_network, + image_embed_dim=out_dim, + condition_on_text_encodings=False, + timesteps=timesteps, + cond_drop_prob=0.2, + image_embed_scale=None, + ) + + utils.count_params(model.diffusion_prior) + utils.count_params(model) + + +# ### Setup optimizer / lr / ckpt saving + +# In[16]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] + +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] +if use_prior: + opt_grouped_parameters.extend([ + {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0} + ]) + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*num_iterations_per_epoch)) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + if accelerator.is_main_process: + unwrapped_model = accelerator.unwrap_model(model) + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + print(f"\n---saved {outdir}/{tag} ckpt!---\n") + +def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): + print(f"\n---loading {outdir}/{tag}.pth ckpt---\n") + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + state_dict = checkpoint['model_state_dict'] + if multisubj_loading: # remove incompatible ridge layer that will otherwise error + state_dict.pop('ridge.linears.0.weight',None) + model.load_state_dict(state_dict, strict=strict) + if load_epoch: + globals()["epoch"] = checkpoint['epoch'] + print("Epoch",epoch) + if load_optimizer: + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + if load_lr: + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + del checkpoint + +print("\nDone with model preparations!") +num_params = utils.count_params(model) + + +# # Weights and Biases + +# In[17]: + + +num_test = 370 + + +# In[18]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'bold5000' + print(f"wandb {wandb_project} run {model_name}") + # need to configure wandb beforehand in terminal with "wandb init"! + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "num_sessions": num_sessions, + "num_params": num_params, + "clip_scale": clip_scale, + "prior_scale": prior_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_samples_per_epoch": num_samples_per_epoch, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + print("wandb_id:",model_name) + wandb.init( + id=model_name, + project=wandb_project, + name=model_name, + config=wandb_config, + resume="allow", + ) +else: + wandb_log = False + + +# # Main + +# In[19]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +torch.cuda.empty_cache() + + +# In[20]: + + +# load multisubject stage1 ckpt if set +if multisubject_ckpt is not None: + load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True) + + +# In[21]: + + +#train_dls = [train_dl[f'subj0{s}'] for s in subj_list] +images_train = images1[0:-370] +images_test = images1[-370::] +voxels_train = voxels1[0:-370] +voxels_test = voxels1[-370::] + +model, optimizer, images_train, images_test, voxels_train, voxels_test, lr_scheduler = accelerator.prepare(model, optimizer, images_train, images_test, voxels_train, voxels_test, lr_scheduler) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + recon_cossim = 0. + test_recon_cossim = 0. + recon_mse = 0. + test_recon_mse = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_blurry_cont_total = 0. + test_loss_clip_total = 0. + + loss_prior_total = 0. + test_loss_prior_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + # pre-load all batches for this epoch (it's MUCH faster to pre-load in bulk than to separate loading per batch) + voxel_iters = {} # empty dict because diff subjects have differing # of voxels + image_iters = torch.zeros(num_iterations_per_epoch, batch_size*len(subj_list), 3, 224, 224).float() + annot_iters = {} + perm_iters, betas_iters, select_iters = {}, {}, {} + """for s, train_dl in enumerate(train_dls): + with torch.cuda.amp.autocast(dtype=data_type): + iter = -1 + for behav0, past_behav0, future_behav0, old_behav0 in train_dl: + # Load images to cpu from hdf5 (requires sorted indexing) + image_idx = behav0[:,0,0].cpu().long().numpy() + image0, image_sorted_idx = np.unique(image_idx, return_index=True) + if len(image0) != len(image_idx): # hdf5 cant handle duplicate indexing + continue + iter += 1 + image0 = torch.tensor(images[image0], dtype=data_type) + image_iters[iter,s*batch_size:s*batch_size+batch_size] = image0 + + # Load voxels for current batch, matching above indexing + voxel_idx = behav0[:,0,5].cpu().long().numpy() + voxel_sorted_idx = voxel_idx[image_sorted_idx] + voxel0 = voxels[f'subj0{subj_list[s]}'][voxel_sorted_idx] + voxel0 = torch.Tensor(voxel0).unsqueeze(1) + + if epoch < int(mixup_pct * num_epochs): + voxel0, perm, betas, select = utils.mixco(voxel0) + perm_iters[f"subj0{subj_list[s]}_iter{iter}"] = perm + betas_iters[f"subj0{subj_list[s]}_iter{iter}"] = betas + select_iters[f"subj0{subj_list[s]}_iter{iter}"] = select + + voxel_iters[f"subj0{subj_list[s]}_iter{iter}"] = voxel0 + + if iter >= num_iterations_per_epoch-1: + break""" + + # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each + for train_i in range(int((len(voxels1)-370)/batch_size)): + with torch.cuda.amp.autocast(dtype=data_type): + random_numbers = [random.randint(0, len(voxels_train)-1) for _ in range(batch_size)] + optimizer.zero_grad() + loss=0. + + #voxel_list = [voxel_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + #image = image_iters[train_i].detach() + + image = images_train[random_numbers]#.unsqueeze(0) + image = image.to(device) + #print(image.shape) + if use_image_aug: + image = img_augment(image) + + clip_target = clip_img_embedder(image) + assert not torch.any(torch.isnan(clip_target)) + + if False: #epoch < int(mixup_pct * num_epochs): + perm_list = [perm_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + perm = torch.cat(perm_list, dim=0) + betas_list = [betas_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + betas = torch.cat(betas_list, dim=0) + select_list = [select_iters[f"subj0{s}_iter{train_i}"].detach().to(device) for s in subj_list] + select = torch.cat(select_list, dim=0) + + voxel = voxels_train[random_numbers].unsqueeze(1).to(device) + #print(voxel.shape) + #voxel_ridge_list = [model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)] + #voxel_ridge = torch.cat(voxel_ridge_list, dim=0) + voxel_ridge = model.ridge(voxel,0) + + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if use_prior: + loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target) + loss_prior_total += loss_prior.item() + loss_prior *= prior_scale + loss += loss_prior + + recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item() + recon_mse += mse(prior_out, clip_target).item() + + if clip_scale>0: + if False: #epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, transformer_feats = blurry_image_enc_ + + image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215 + loss_blurry = l1(image_enc_pred, image_enc) + loss_blurry_total += loss_blurry.item() + + if False: #epoch < int(mixup_pct * num_epochs): + image_enc_shuf = image_enc[perm] + betas_shape = [-1] + [1]*(len(image_enc.shape)-1) + image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \ + image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape) + + image_norm = (image - mean)/std + image_aug = (blur_augs(image) - mean)/std + _, cnx_embeds = cnx(image_norm) + _, cnx_aug_embeds = cnx(image_aug) + + cont_loss = utils.soft_cont_loss( + nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1), + nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1), + temp=0.2) + loss_blurry_cont_total += cont_loss.item() + + loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215 + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + blurry_pixcorr += pixcorr.item() + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i in range(1): + # all test samples should be loaded per batch such that test_i should never exceed 0 + # assert len(behav) == num_test + + ## Average same-image repeats ## + if False: #test_image is None: + voxel = voxels[f'subj0{subj}'][behav[:,0,5].cpu().long()].unsqueeze(1) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if len(locs)==1: + locs = locs.repeat(3) + elif len(locs)==2: + locs = locs.repeat(2)[:3] + assert len(locs)==3 + if test_image is None: + test_image = torch.Tensor(images[im][None]) + test_voxel = voxel[locs][None] + else: + test_image = torch.vstack((test_image, torch.Tensor(images[im][None]))) + test_voxel = torch.vstack((test_voxel, voxel[locs][None])) + + loss=0. + + #test_indices = torch.arange(len(test_voxel))[:300] + voxel = voxels_test.to(device).unsqueeze(1) + image = images_test.to(device) + #assert len(image) == 300 + + clip_target = clip_img_embedder(image.float()) + + voxel_ridge = model.ridge(voxel,0) # 0th index of subj_list + backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + #for rep in range(3): + # voxel_ridge = model.ridge(voxel[:,rep],0) # 0th index of subj_list + # backbone0, clip_voxels0, blurry_image_enc_ = model.backbone(voxel_ridge) + # if rep==0: + # clip_voxels = clip_voxels0 + # backbone = backbone0 + # else: + # clip_voxels += clip_voxels0 + # backbone += backbone0 + #clip_voxels /= 3 + #backbone /= 3 + + if clip_scale>0: + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + # for some evals, only doing a subset of the samples per batch because of computational cost + random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False) + + if use_prior: + loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps]) + test_loss_prior_total += loss_prior.item() + loss_prior *= prior_scale + loss += loss_prior + + if clip_scale>0: + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss += loss_clip + + if blurry_recon: + image_enc_pred, _ = blurry_image_enc_ + blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1) + pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + test_blurry_pixcorr += pixcorr.item() + + if clip_scale>0: + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/recon_cossim": recon_cossim / (train_i + 1), + "test/recon_cossim": test_recon_cossim / (test_i + 1), + "train/recon_mse": recon_mse / (train_i + 1), + "test/recon_mse": test_recon_mse / (test_i + 1), + "train/loss_prior": loss_prior_total / (train_i + 1), + "test/loss_prior": test_loss_prior_total / (test_i + 1), + } + + # if finished training, save jpg recons if they exist + if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0): + if blurry_recon: + image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215 + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/blur_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + if wandb_log: wandb.log(logs) + + # Save model checkpoint and reconstruct + if (ckpt_saving) and (epoch % ckpt_interval == 0): + save_ckpt(f'last') + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') + + +# In[ ]: + + +losses + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ebd63d53a56f124809021c5402c137abb509fde9 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml @@ -0,0 +1,109 @@ +wandb_version: 1 + +model_name: + desc: null + value: augmented_image_one +global_batch_size: + desc: null + value: '21' +batch_size: + desc: null + value: 21 +num_epochs: + desc: null + value: 80 +num_sessions: + desc: null + value: 14 +num_params: + desc: null + value: 2154632456 +clip_scale: + desc: null + value: 1.0 +prior_scale: + desc: null + value: 30.0 +blur_scale: + desc: null + value: 0.5 +use_image_aug: + desc: null + value: true +max_lr: + desc: null + value: 0.0003 +mixup_pct: + desc: null + value: 0.33 +num_samples_per_epoch: + desc: null + value: 5254 +num_test: + desc: null + value: 370 +ckpt_interval: + desc: null + value: 999 +ckpt_saving: + desc: null + value: false +seed: + desc: null + value: 42 +distributed: + desc: null + value: false +num_devices: + desc: null + value: 1 +world_size: + desc: null + value: 1 +_wandb: + desc: null + value: + code_path: code/src/TrainBold5000.py + python_version: 3.11.9 + cli_version: 0.17.1 + framework: huggingface + huggingface_version: 4.37.2 + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1721533172 + t: + 1: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 2: + - 1 + - 9 + - 11 + - 41 + - 49 + - 55 + - 63 + - 71 + - 79 + - 83 + - 103 + 3: + - 13 + - 14 + - 16 + - 23 + 4: 3.11.9 + 5: 0.17.1 + 6: 4.37.2 + 8: + - 5 + 13: linux-x86_64 diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/diff.patch b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/diff.patch new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..e0873221c3f167b63dcc15747b36c3d8844f292e --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log @@ -0,0 +1,100 @@ + +augmented_image_one starting with epoch 0 / 80 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 80/80 [1:39:38<00:00, 74.74s/it, test/blurry_pixcorr=0, test/loss=19.2, test/loss_clip_total=5.15, test/loss_prior=0.467, test/num_steps=80, test/recon_cossim=0, test/recon_mse=0, test/test_bwd_pct_correct=0.0892, test/test_fwd_pct_correct=0.0865, train/blurry_pixcorr=0, train/bwd_pct_correct=0.998, train/fwd_pct_correct=0.998, train/loss=8.07, train/loss_blurry_cont_total=0, train/loss_blurry_total=0, train/loss_clip_total=0.00295, train/loss_prior=0.269, train/lr=4.09e-6, train/num_steps=18560, train/recon_cossim=0.799, train/recon_mse=0.269] +===Finished!=== \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..554ebdcc6e29d92dc7948879734f45b6455e6093 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt @@ -0,0 +1,215 @@ +Babel==2.15.0 +CoCa-pytorch==0.1.0 +GitPython==3.1.43 +Jinja2==3.1.4 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Pygments==2.18.0 +QtPy==2.4.1 +Send2Trash==1.8.3 +absl-py==2.1.0 +accelerate==0.24.1 +aiohttp==3.9.5 +aiosignal==1.3.1 +annotated-types==0.7.0 +antlr4-python3-runtime==4.9.3 +anyio==4.4.0 +argon2-cffi-bindings==21.2.0 +argon2-cffi==23.1.0 +arrow==1.3.0 +asttokens==2.4.1 +async-lru==2.0.4 +attrs==23.2.0 +beartype==0.18.5 +beautifulsoup4==4.12.3 +bleach==6.1.0 +braceexpand==0.1.7 +certifi==2024.6.2 +cffi==1.16.0 +charset-normalizer==3.3.2 +click==8.1.7 +clip-anytorch==2.6.0 +clip==1.0 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +dalle2-pytorch==1.15.6 +datasets==2.20.0 +debugpy==1.8.1 +decorator==5.1.1 +deepspeed==0.13.1 +defusedxml==0.7.1 +diffusers==0.23.0 +dill==0.3.8 +docker-pycreds==0.4.0 +einops==0.8.0 +einx==0.3.0 +ema-pytorch==0.5.0 +embedding-reader==1.7.0 +evaluate==0.4.1 +executing==2.0.1 +fastjsonschema==2.20.0 +filelock==3.15.1 +fonttools==4.53.0 +fqdn==1.5.1 +frozendict==2.4.4 +frozenlist==1.4.1 +fsspec==2024.5.0 +ftfy==6.2.0 +gitdb==4.0.11 +h11==0.14.0 +h5py==3.10.0 +hjson==3.1.0 +httpcore==1.0.5 +httpx==0.27.0 +huggingface-hub==0.23.4 +idna==3.7 +imageio==2.34.1 +importlib_metadata==7.1.0 +ipykernel==6.29.4 +ipython==8.25.0 +ipywidgets==8.1.3 +isoduration==20.11.0 +jedi==0.19.1 +joblib==1.4.2 +json5==0.9.25 +jsonpointer==3.0.0 +jsonschema-specifications==2023.12.1 +jsonschema==4.22.0 +jupyter-console==6.6.3 +jupyter-events==0.10.0 +jupyter-lsp==2.2.5 +jupyter==1.0.0 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +jupyter_server==2.14.1 +jupyter_server_terminals==0.5.3 +jupyterlab==4.2.2 +jupyterlab_nvdashboard==0.11.0 +jupyterlab_pygments==0.3.0 +jupyterlab_server==2.27.2 +jupyterlab_widgets==3.0.11 +kiwisolver==1.4.5 +kornia==0.7.1 +lazy_loader==0.4 +lightning-utilities==0.11.2 +matplotlib-inline==0.1.7 +matplotlib==3.8.2 +mistune==3.0.2 +mpmath==1.3.0 +multidict==6.0.5 +multiprocess==0.70.16 +nbclient==0.10.0 +nbconvert==7.16.4 +nbformat==5.10.4 +nest-asyncio==1.6.0 +networkx==3.3 +nibabel==5.2.1 +ninja==1.11.1.1 +nltk==3.8.1 +notebook==7.2.1 +notebook_shim==0.2.4 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.18.1 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +omegaconf==2.3.0 +open-clip-torch==2.24.0 +overrides==7.7.0 +packaging==24.1 +pandas==2.2.0 +pandocfilters==1.5.1 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.3.0 +pip==24.1.1 +platformdirs==4.2.2 +prometheus_client==0.20.0 +prompt_toolkit==3.0.47 +protobuf==5.27.1 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +py-cpuinfo==9.0.0 +pyarrow-hotfix==0.6 +pyarrow==15.0.2 +pycparser==2.22 +pydantic==2.7.4 +pydantic_core==2.18.4 +pynvml==11.5.0 +pyparsing==3.1.2 +python-dateutil==2.9.0.post0 +python-json-logger==2.0.7 +pytorch-lightning==2.0.1 +pytorch-warmup==0.1.1 +pytz==2024.1 +pyzmq==26.0.3 +qtconsole==5.5.2 +referencing==0.35.1 +regex==2024.5.15 +requests==2.32.3 +resize-right==0.0.2 +responses==0.18.0 +rfc3339-validator==0.1.4 +rfc3986-validator==0.1.1 +rotary-embedding-torch==0.6.2 +rouge_score==0.1.2 +rpds-py==0.18.1 +safetensors==0.4.3 +scikit-image==0.22.0 +scikit-learn==1.5.0 +scipy==1.13.1 +sentence-transformers==2.5.1 +sentencepiece==0.2.0 +sentry-sdk==2.5.1 +setproctitle==1.3.3 +setuptools==65.5.0 +six==1.16.0 +smmap==5.0.1 +sniffio==1.3.1 +soupsieve==2.5 +stack-data==0.6.3 +sympy==1.12.1 +terminado==0.18.1 +threadpoolctl==3.5.0 +tifffile==2024.5.22 +timm==1.0.3 +tinycss2==1.3.0 +tokenizers==0.15.2 +torch-fidelity==0.3.0 +torch==2.1.0 +torchmetrics==1.3.0.post0 +torchvision==0.16.0 +tornado==6.4.1 +tqdm==4.66.4 +traitlets==5.14.3 +transformers==4.37.2 +triton==2.1.0 +types-python-dateutil==2.9.0.20240316 +typing_extensions==4.12.2 +tzdata==2024.1 +umap==0.1.1 +uri-template==1.3.0 +urllib3==2.2.1 +vector-quantize-pytorch==1.14.24 +wandb==0.17.1 +wcwidth==0.2.13 +webcolors==24.6.0 +webdataset==0.2.73 +webencodings==0.5.1 +websocket-client==1.8.0 +widgetsnbextension==4.0.11 +x-clip==0.14.4 +xformers==0.0.22.post7 +xxhash==3.4.1 +yarl==1.9.4 +zipp==3.19.2 \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-metadata.json b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3aff478360c0c4a049f3a3c548beefa10541dac0 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-metadata.json @@ -0,0 +1,1059 @@ +{ + "os": "Linux-5.15.0-1058-aws-x86_64-with-glibc2.31", + "python": "3.11.9", + "heartbeatAt": "2024-07-21T03:39:32.872470", + "startedAt": "2024-07-21T03:39:31.903867", + "docker": null, + "cuda": null, + "args": [ + "--data_path=/weka/proj-medarc/shared/mindeyev2_dataset", + "--data_path=/weka/proj-medarc/shared/bold5000/v1", + "--cache_dir=/weka/proj-medarc/shared/cache", + "--model_name=augmented_image_one", + "--no-multi_subject", + "--subj=1", + "--batch_size=21", + "--num_sessions=14", + "--hidden_dim=4096", + "--clip_scale=1.", + "--no-blurry_recon", + "--blur_scale=.5", + "--use_prior", + "--prior_scale=30", + "--n_blocks=4", + "--max_lr=3e-4", + "--mixup_pct=.33", + "--num_epochs=80", + "--use_image_aug", + "--ckpt_interval=999", + "--no-ckpt_saving", + "--wandb_log" + ], + "state": "running", + "program": "/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainBold5000.py", + "codePathLocal": "TrainBold5000.py", + "codePath": "src/TrainBold5000.py", + "git": { + "remote": "https://github.com/MedARC-AI/MindEyeV2.git", + "commit": "a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe" + }, + "email": null, + "root": "/weka/proj-fmri/ckadirt/MindEyeV2", + "host": "ip-10-0-133-122", + "username": "ckadirt", + "executable": "/admin/home-ckadirt/fmri/bin/python", + "cpu_count": 96, + "cpu_count_logical": 192, + "cpu_freq": { + "current": 3013.2220989583425, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 3561.487, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.597, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.063, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.848, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.57, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.821, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3599.287, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.549, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3599.545, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3598.813, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3599.214, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3561.664, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3591.44, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 3597.009, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2649.998, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 232.4169158935547, + "used": 167.85649871826172 + } + }, + "gpu": "NVIDIA H100 80GB HBM3", + "gpu_count": 8, + "gpu_devices": [ + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + }, + { + "name": "NVIDIA H100 80GB HBM3", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 1999.962490081787 + } +} diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..0bd0d9e5de42c57c30b215d3ca085c51f675df42 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/loss": 8.074435388219767, "test/loss": 19.17922592163086, "train/lr": 4.086126486667003e-06, "train/num_steps": 18560, "test/num_steps": 80, "train/fwd_pct_correct": 0.998152709469713, "train/bwd_pct_correct": 0.998152709469713, "test/test_fwd_pct_correct": 0.08648648858070374, "test/test_bwd_pct_correct": 0.08918919414281845, "train/loss_clip_total": 0.0029489212888306766, "train/loss_blurry_total": 0.0, "train/loss_blurry_cont_total": 0.0, "test/loss_clip_total": 5.154852867126465, "train/blurry_pixcorr": 0.0, "test/blurry_pixcorr": 0.0, "train/recon_cossim": 0.7994296527628241, "test/recon_cossim": 0.0, "train/recon_mse": 0.26904954934685393, "test/recon_mse": 0.0, "train/loss_prior": 0.26904954934685393, "test/loss_prior": 0.4674791097640991, "_timestamp": 1721539158.6454647, "_runtime": 5986.568691730499, "_step": 79, "_wandb": {"runtime": 5986}} \ No newline at end of file diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug-internal.log b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..7041ee345aef581b67e53037268fdc9c431e2e00 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug-internal.log @@ -0,0 +1,8316 @@ +2024-07-21 03:39:32,082 INFO StreamThr :2236926 [internal.py:wandb_internal():85] W&B internal server running at pid: 2236926, started at: 2024-07-21 03:39:32.073639 +2024-07-21 03:39:32,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status +2024-07-21 03:39:32,098 INFO WriterThread:2236926 [datastore.py:open_for_write():87] open: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/run-augmented_image_one.wandb +2024-07-21 03:39:32,103 DEBUG SenderThread:2236926 [sender.py:send():379] send: header +2024-07-21 03:39:32,138 DEBUG SenderThread:2236926 [sender.py:send():379] send: run +2024-07-21 03:39:32,158 INFO SenderThread:2236926 [sender.py:_setup_resume():749] checking resume status for None/bold5000/augmented_image_one +2024-07-21 03:39:32,637 INFO SenderThread:2236926 [dir_watcher.py:__init__():211] watching files in: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files +2024-07-21 03:39:32,637 INFO SenderThread:2236926 [sender.py:_start_run_threads():1188] run started: augmented_image_one with start time 1721533172.076773 +2024-07-21 03:39:32,666 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: check_version +2024-07-21 03:39:32,667 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: check_version +2024-07-21 03:39:32,737 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: run_start +2024-07-21 03:39:32,811 DEBUG HandlerThread:2236926 [system_info.py:__init__():26] System info init +2024-07-21 03:39:32,811 DEBUG HandlerThread:2236926 [system_info.py:__init__():41] System info init done +2024-07-21 03:39:32,811 INFO HandlerThread:2236926 [system_monitor.py:start():194] Starting system monitor +2024-07-21 03:39:32,811 INFO SystemMonitor:2236926 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-07-21 03:39:32,812 INFO HandlerThread:2236926 [system_monitor.py:probe():214] Collecting system info +2024-07-21 03:39:32,812 INFO SystemMonitor:2236926 [interfaces.py:start():188] Started cpu monitoring +2024-07-21 03:39:32,812 INFO SystemMonitor:2236926 [interfaces.py:start():188] Started disk monitoring +2024-07-21 03:39:32,813 INFO SystemMonitor:2236926 [interfaces.py:start():188] Started gpu monitoring +2024-07-21 03:39:32,813 INFO SystemMonitor:2236926 [interfaces.py:start():188] Started memory monitoring +2024-07-21 03:39:32,814 INFO SystemMonitor:2236926 [interfaces.py:start():188] Started network monitoring +2024-07-21 03:39:32,872 DEBUG HandlerThread:2236926 [system_info.py:probe():152] Probing system +2024-07-21 03:39:32,880 DEBUG HandlerThread:2236926 [system_info.py:_probe_git():137] Probing git +2024-07-21 03:39:32,906 DEBUG HandlerThread:2236926 [system_info.py:_probe_git():145] Probing git done +2024-07-21 03:39:32,906 DEBUG HandlerThread:2236926 [system_info.py:probe():200] Probing system done +2024-07-21 03:39:32,906 DEBUG HandlerThread:2236926 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-1058-aws-x86_64-with-glibc2.31', 'python': '3.11.9', 'heartbeatAt': '2024-07-21T03:39:32.872470', 'startedAt': '2024-07-21T03:39:31.903867', 'docker': None, 'cuda': None, 'args': ('--data_path=/weka/proj-medarc/shared/mindeyev2_dataset', '--data_path=/weka/proj-medarc/shared/bold5000/v1', '--cache_dir=/weka/proj-medarc/shared/cache', '--model_name=augmented_image_one', '--no-multi_subject', '--subj=1', '--batch_size=21', '--num_sessions=14', '--hidden_dim=4096', '--clip_scale=1.', '--no-blurry_recon', '--blur_scale=.5', '--use_prior', '--prior_scale=30', '--n_blocks=4', '--max_lr=3e-4', '--mixup_pct=.33', '--num_epochs=80', '--use_image_aug', '--ckpt_interval=999', '--no-ckpt_saving', '--wandb_log'), 'state': 'running', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainBold5000.py', 'codePathLocal': 'TrainBold5000.py', 'codePath': 'src/TrainBold5000.py', 'git': {'remote': 'https://github.com/MedARC-AI/MindEyeV2.git', 'commit': 'a3588f0fadc81bdb0cc3e15993c01f8dd64dc7fe'}, 'email': None, 'root': '/weka/proj-fmri/ckadirt/MindEyeV2', 'host': 'ip-10-0-133-122', 'username': 'ckadirt', 'executable': '/admin/home-ckadirt/fmri/bin/python', 'cpu_count': 96, 'cpu_count_logical': 192, 'cpu_freq': {'current': 3013.2220989583425, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 3561.487, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3598.597, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3597.063, 'min': 0.0, 'max': 0.0}, {'current': 3598.848, 'min': 0.0, 'max': 0.0}, {'current': 3598.57, 'min': 0.0, 'max': 0.0}, {'current': 3598.821, 'min': 0.0, 'max': 0.0}, {'current': 3599.287, 'min': 0.0, 'max': 0.0}, {'current': 3598.549, 'min': 0.0, 'max': 0.0}, {'current': 3599.545, 'min': 0.0, 'max': 0.0}, {'current': 3598.813, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3599.214, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3561.664, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3591.44, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 3597.009, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}, {'current': 2649.998, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 232.4169158935547, 'used': 167.85649871826172}}, 'gpu': 'NVIDIA H100 80GB HBM3', 'gpu_count': 8, 'gpu_devices': [{'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}, {'name': 'NVIDIA H100 80GB HBM3', 'memory_total': 85520809984}], 'memory': {'total': 1999.962490081787}} +2024-07-21 03:39:32,907 INFO HandlerThread:2236926 [system_monitor.py:probe():224] Finished collecting system info +2024-07-21 03:39:32,907 INFO HandlerThread:2236926 [system_monitor.py:probe():227] Publishing system info +2024-07-21 03:39:32,907 DEBUG HandlerThread:2236926 [system_info.py:_save_code():44] Saving code +2024-07-21 03:39:32,959 DEBUG HandlerThread:2236926 [system_info.py:_save_code():67] Saving code done +2024-07-21 03:39:32,959 DEBUG HandlerThread:2236926 [system_info.py:_save_patches():84] Saving git patches +2024-07-21 03:39:33,648 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/diff.patch +2024-07-21 03:39:33,648 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src/TrainBold5000.py +2024-07-21 03:39:33,649 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src +2024-07-21 03:39:33,649 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code +2024-07-21 03:39:38,328 ERROR HandlerThread:2236926 [system_info.py:_save_patches():125] Error generating diff: Command '['git', 'diff', '--submodule=diff', 'HEAD']' timed out after 5 seconds +2024-07-21 03:39:38,328 DEBUG HandlerThread:2236926 [system_info.py:_save_patches():126] Saving git patches done +2024-07-21 03:39:38,340 INFO HandlerThread:2236926 [system_monitor.py:probe():229] Finished publishing system info +2024-07-21 03:39:38,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:39:38,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: keepalive +2024-07-21 03:39:38,349 DEBUG SenderThread:2236926 [sender.py:send():379] send: files +2024-07-21 03:39:38,349 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-metadata.json with policy now +2024-07-21 03:39:38,349 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file code/src/TrainBold5000.py with policy now +2024-07-21 03:39:38,687 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-metadata.json +2024-07-21 03:39:38,765 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: python_packages +2024-07-21 03:39:38,765 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: python_packages +2024-07-21 03:39:38,765 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:39:38,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:38,770 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:39:38,876 INFO wandb-upload_0:2236926 [upload_job.py:push():130] Uploaded file /tmp/tmpbwbb8gdqwandb/qd6o8asb-wandb-metadata.json +2024-07-21 03:39:38,945 DEBUG SenderThread:2236926 [sender.py:send():379] send: telemetry +2024-07-21 03:39:39,117 INFO wandb-upload_1:2236926 [upload_job.py:push():130] Uploaded file /tmp/tmpbwbb8gdqwandb/bg9joa7p-code/src/TrainBold5000.py +2024-07-21 03:39:39,698 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt +2024-07-21 03:39:39,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:40,708 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:39:40,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:41,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:42,725 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:39:42,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:42,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:39:43,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:44,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:45,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:46,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:47,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:48,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:39:48,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:49,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:50,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:51,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:52,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:53,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:39:53,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:39:53,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:53,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:39:54,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:55,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:56,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:57,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:58,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:39:59,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:39:59,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:00,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:01,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:02,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:03,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:04,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:05,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:05,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:05,938 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml +2024-07-21 03:40:06,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:07,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:08,765 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:40:08,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:40:08,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:09,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:10,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:10,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:11,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:12,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:13,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:14,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:15,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:16,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:16,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:17,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:18,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:19,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:20,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:21,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:22,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:22,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:23,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:40:23,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:40:23,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:24,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:25,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:26,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:27,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:27,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:28,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:29,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:30,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:31,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:32,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:32,814 DEBUG SystemMonitor:2236926 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-07-21 03:40:32,816 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:40:33,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:33,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:34,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:35,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:36,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:37,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:38,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:40:38,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:40:38,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:38,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:39,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:40,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:41,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:42,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:43,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:44,767 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:44,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:45,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:46,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:47,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:48,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:49,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:49,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:50,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:51,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:52,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:53,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:40:53,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:40:53,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:54,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:54,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:40:55,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:40:55,768 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:40:55,768 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:40:55,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:55,779 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:40:56,502 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_created():271] file/dir created: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:40:56,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:57,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:58,526 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:40:58,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:40:59,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:00,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:00,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:01,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:02,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:02,818 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:41:03,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:04,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:05,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:05,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:06,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:07,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:08,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:41:08,767 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:41:08,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:09,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:10,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:10,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:11,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:12,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:13,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:14,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:15,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:16,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:16,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:17,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:18,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:19,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:20,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:21,768 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:21,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:22,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:23,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:41:23,766 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:41:23,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:24,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:25,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:26,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:26,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:27,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:28,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:29,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:30,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:31,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:32,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:32,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:32,819 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:41:33,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:34,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:35,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:36,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:37,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:37,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:38,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:41:38,767 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:41:38,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:39,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:40,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:41,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:42,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:42,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:43,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:44,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:45,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:46,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:47,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:48,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:48,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:49,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:50,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:51,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:52,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:53,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:41:53,767 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:41:53,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:53,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:54,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:55,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:56,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:57,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:58,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:41:59,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:41:59,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:00,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:01,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:02,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:02,826 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:42:03,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:04,769 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:04,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:05,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:06,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:07,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:08,766 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:42:08,767 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:42:08,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:09,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:09,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:10,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:42:10,375 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:42:10,375 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:42:10,388 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:42:10,529 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:42:10,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:11,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:12,557 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:42:12,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:13,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:14,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:15,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:15,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:16,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:17,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:18,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:19,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:20,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:21,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:21,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:22,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:23,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:42:23,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:42:23,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:24,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:25,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:26,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:26,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:27,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:28,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:29,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:30,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:31,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:32,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:32,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:32,823 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:42:33,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:34,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:35,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:36,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:37,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:37,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:38,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:42:38,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:42:38,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:39,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:40,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:41,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:42,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:42,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:43,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:44,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:45,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:46,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:47,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:48,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:48,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:49,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:50,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:51,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:52,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:53,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:53,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:42:53,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:42:53,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:54,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:55,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:56,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:57,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:58,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:42:59,770 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:42:59,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:00,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:01,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:02,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:02,824 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:43:03,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:04,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:05,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:05,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:06,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:07,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:08,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:43:08,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:43:08,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:09,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:10,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:10,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:11,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:12,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:13,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:14,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:15,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:16,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:16,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:17,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:18,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:19,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:20,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:21,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:22,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:22,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:23,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:43:23,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:43:23,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:24,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:25,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:43:25,091 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:43:25,092 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:43:25,114 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:43:25,585 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:43:25,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:26,598 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:43:26,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:27,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:28,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:28,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:29,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:30,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:31,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:32,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:32,837 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:43:33,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:33,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:34,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:35,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:36,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:37,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:38,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:38,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:43:38,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:43:38,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:39,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:40,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:41,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:42,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:43,771 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:43,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:44,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:45,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:46,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:47,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:48,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:48,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:49,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:50,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:51,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:52,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:53,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:53,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:43:53,778 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:43:53,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:54,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:55,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:56,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:57,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:58,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:43:58,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:43:59,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:00,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:01,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:02,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:02,828 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:44:03,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:04,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:04,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:05,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:06,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:07,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:08,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:44:08,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:44:08,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:09,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:09,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:10,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:11,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:12,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:13,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:14,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:15,772 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:15,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:16,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:17,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:18,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:19,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:20,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:20,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:21,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:22,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:23,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:44:23,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:44:23,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:24,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:25,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:25,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:26,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:27,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:28,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:29,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:30,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:31,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:31,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:32,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:32,830 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:44:33,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:34,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:35,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:36,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:37,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:37,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:38,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:44:38,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:44:38,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:39,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:39,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:44:39,983 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:44:39,984 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:44:39,998 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:44:40,658 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:44:40,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:41,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:42,687 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:44:42,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:42,999 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:43,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:44,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:45,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:46,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:47,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:48,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:48,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:49,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:50,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:51,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:52,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:53,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:44:53,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:44:53,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:53,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:54,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:55,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:56,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:57,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:58,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:44:59,773 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:44:59,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:00,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:01,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:02,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:02,831 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:45:03,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:04,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:04,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:05,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:06,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:07,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:08,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:45:08,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:45:08,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:09,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:09,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:10,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:11,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:12,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:13,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:14,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:15,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:15,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:16,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:17,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:18,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:19,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:20,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:20,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:21,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:22,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:23,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:45:23,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:45:23,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:24,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:25,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:25,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:26,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:27,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:28,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:29,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:30,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:31,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:31,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:32,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:32,835 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:45:33,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:34,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:35,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:36,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:37,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:37,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:38,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:45:38,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:45:38,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:39,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:40,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:41,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:42,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:42,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:43,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:44,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:45,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:46,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:47,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:48,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:48,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:49,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:50,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:51,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:52,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:53,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:53,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:45:53,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:45:53,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:54,734 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:45:54,736 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:45:54,736 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:45:54,750 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:45:54,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:55,744 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:45:55,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:56,758 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:45:56,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:57,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:58,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:45:59,774 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:45:59,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:00,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:01,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:02,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:02,834 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:46:03,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:04,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:04,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:05,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:06,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:07,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:08,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:46:08,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:46:08,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:09,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:09,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:10,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:11,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:12,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:13,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:14,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:15,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:15,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:16,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:17,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:18,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:19,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:20,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:20,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:21,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:22,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:23,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:46:23,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:46:23,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:24,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:25,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:25,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:26,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:27,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:28,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:29,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:30,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:31,775 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:31,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:32,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:32,837 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:46:33,805 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:34,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:35,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:36,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:37,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:37,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:38,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:46:38,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:46:38,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:39,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:40,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:41,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:42,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:42,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:43,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:44,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:45,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:46,806 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:47,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:48,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:48,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:49,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:50,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:51,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:52,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:53,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:53,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:46:53,779 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:46:53,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:54,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:55,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:56,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:57,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:58,807 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:46:59,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:46:59,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:00,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:01,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:02,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:02,837 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:47:03,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:04,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:04,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:05,808 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:06,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:07,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:08,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:47:08,780 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:47:08,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:09,390 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:47:09,391 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:47:09,392 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:47:09,407 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:47:09,804 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:47:09,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:10,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:10,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:10,820 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:47:11,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:12,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:13,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:14,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:15,776 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:15,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:16,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:17,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:18,809 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:19,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:20,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:20,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:21,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:22,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:23,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:47:23,780 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:47:23,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:24,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:25,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:25,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:26,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:27,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:28,810 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:29,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:30,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:31,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:31,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:32,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:32,839 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:47:33,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:34,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:35,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:36,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:36,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:37,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:38,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:47:38,780 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:47:38,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:39,811 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:40,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:41,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:41,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:42,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:43,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:44,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:45,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:46,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:47,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:47,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:48,812 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:49,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:50,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:51,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:52,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:53,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:53,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:47:53,783 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:47:53,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:54,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:55,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:56,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:57,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:58,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:47:59,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:47:59,813 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:00,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:01,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:02,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:02,841 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:48:03,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:04,777 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:04,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:05,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:06,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:07,814 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:08,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:48:08,783 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:48:08,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:09,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:09,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:10,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:11,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:12,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:13,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:14,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:15,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:15,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:16,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:17,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:18,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:19,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:20,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:21,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:21,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:22,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:23,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:48:23,783 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:48:23,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:24,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:48:24,152 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:48:24,152 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:48:24,173 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:48:24,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:24,927 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:48:24,927 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:48:25,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:26,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:26,957 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:48:27,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:27,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:28,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:29,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:30,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:31,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:32,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:32,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:32,842 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:48:33,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:34,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:35,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:36,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:37,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:37,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:38,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:48:38,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:48:38,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:39,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:40,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:41,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:42,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:42,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:43,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:44,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:45,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:46,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:47,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:48,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:48,818 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:49,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:50,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:51,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:52,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:53,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:53,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:48:53,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:48:53,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:54,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:55,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:56,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:57,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:58,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:48:59,778 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:48:59,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:00,819 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:01,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:02,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:02,847 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:49:03,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:04,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:04,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:05,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:06,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:07,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:08,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:49:08,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:49:08,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:09,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:09,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:10,820 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:11,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:12,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:13,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:14,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:15,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:15,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:16,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:17,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:18,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:19,821 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:20,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:20,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:21,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:22,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:23,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:49:23,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:49:23,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:24,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:25,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:25,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:26,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:27,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:28,822 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:29,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:30,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:31,779 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:31,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:32,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:32,846 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:49:33,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:34,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:35,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:36,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:36,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:37,823 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:38,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:49:38,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:49:38,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:38,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:49:38,959 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:49:38,960 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:49:38,983 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:49:38,986 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:49:39,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:39,991 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:49:40,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:41,000 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:49:41,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:41,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:42,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:43,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:44,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:45,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:46,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:47,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:47,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:48,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:49,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:50,824 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:51,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:52,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:52,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:53,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:49:53,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:49:53,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:54,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:55,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:56,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:57,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:57,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:49:58,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:49:59,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:00,825 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:01,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:02,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:02,847 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:50:03,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:03,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:04,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:05,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:06,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:07,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:08,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:08,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:50:08,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:50:08,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:09,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:10,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:11,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:12,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:13,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:14,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:14,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:15,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:16,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:17,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:18,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:19,780 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:19,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:20,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:21,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:22,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:23,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:50:23,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:50:23,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:24,827 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:24,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:25,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:26,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:27,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:28,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:29,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:30,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:30,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:31,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:32,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:32,850 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:50:33,828 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:34,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:35,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:35,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:36,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:37,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:38,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:50:38,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:50:38,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:39,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:40,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:40,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:41,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:42,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:43,829 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:44,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:45,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:46,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:46,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:47,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:48,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:49,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:50,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:51,781 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:51,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:52,830 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:53,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:50:53,784 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:50:53,826 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:50:53,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:53,959 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:50:53,959 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:50:53,972 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:50:54,058 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:50:54,831 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:55,066 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:50:55,831 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:56,831 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:56,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:50:57,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:58,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:50:59,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:00,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:01,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:02,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:02,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:02,850 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:51:03,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:04,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:05,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:06,832 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:07,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:07,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:08,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:51:08,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:51:08,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:09,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:10,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:11,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:12,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:12,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:13,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:14,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:15,833 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:16,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:17,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:18,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:18,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:19,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:20,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:21,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:22,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:23,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:51:23,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:51:23,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:23,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:24,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:25,834 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:26,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:27,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:28,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:29,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:29,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:30,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:31,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:32,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:32,852 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:51:33,835 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:34,782 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:34,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:35,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:36,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:37,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:38,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:51:38,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:51:38,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:39,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:39,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:40,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:41,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:42,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:43,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:44,836 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:45,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:45,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:46,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:47,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:48,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:49,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:50,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:51,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:51,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:52,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:53,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:51:53,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:51:53,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:54,837 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:55,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:56,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:56,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:51:57,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:58,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:51:59,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:00,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:01,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:02,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:02,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:02,853 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:52:03,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:04,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:05,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:06,838 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:07,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:07,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:08,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:52:08,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:52:08,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:09,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:52:09,023 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:52:09,023 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:52:09,037 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:52:09,144 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:52:09,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:10,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:11,170 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:52:11,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:12,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:13,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:13,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:14,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:15,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:16,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:17,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:18,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:18,839 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:19,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:20,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:21,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:22,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:23,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:23,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:52:23,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:52:23,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:24,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:25,840 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:26,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:27,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:28,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:28,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:29,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:30,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:31,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:32,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:32,860 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:52:33,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:34,783 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:34,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:35,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:36,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:37,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:38,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:52:38,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:52:38,841 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:39,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:39,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:40,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:41,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:42,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:43,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:44,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:45,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:45,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:46,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:47,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:48,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:49,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:50,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:50,842 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:51,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:52,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:53,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:52:53,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:52:53,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:54,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:55,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:55,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:52:56,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:57,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:58,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:52:59,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:00,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:01,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:01,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:02,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:02,856 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:53:03,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:04,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:05,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:06,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:06,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:07,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:08,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:53:08,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:53:08,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:09,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:10,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:11,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:11,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:12,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:13,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:14,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:15,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:16,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:17,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:17,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:18,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:19,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:20,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:21,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:22,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:23,784 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:23,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:53:23,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:53:23,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:24,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:53:24,079 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:53:24,079 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:53:24,095 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:53:24,447 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:53:24,447 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:53:24,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:25,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:26,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:27,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:28,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:28,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:29,846 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:30,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:31,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:32,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:32,858 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:53:33,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:33,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:34,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:35,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:36,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:37,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:38,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:38,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:53:38,785 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:53:38,847 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:39,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:40,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:41,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:42,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:43,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:43,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:44,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:45,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:46,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:47,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:48,848 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:49,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:49,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:50,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:51,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:52,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:53,785 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:53:53,786 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:53:53,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:54,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:54,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:53:55,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:56,849 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:57,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:58,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:53:59,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:00,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:00,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:01,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:02,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:02,864 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:54:03,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:04,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:05,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:06,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:06,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:07,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:08,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:54:08,786 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:54:08,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:09,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:10,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:11,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:11,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:12,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:13,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:14,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:15,851 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:16,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:17,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:17,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:18,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:19,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:20,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:21,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:22,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:22,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:23,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:54:23,786 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:54:23,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:24,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:25,852 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:26,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:27,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:27,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:28,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:29,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:30,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:31,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:32,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:32,861 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:54:33,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:33,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:34,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:35,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:36,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:37,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:38,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:38,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:54:38,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:54:38,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:39,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:54:39,431 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:54:39,431 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:54:39,450 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:54:39,689 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:54:39,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:40,704 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:54:40,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:41,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:42,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:43,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:43,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:44,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:45,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:46,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:47,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:48,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:48,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:49,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:50,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:51,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:52,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:53,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:53,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:54:53,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:54:53,855 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:54,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:55,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:56,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:57,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:58,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:54:58,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:54:59,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:00,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:01,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:02,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:02,863 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:55:03,856 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:04,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:04,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:05,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:06,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:07,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:08,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:55:08,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:55:08,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:09,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:09,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:10,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:11,857 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:12,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:13,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:14,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:15,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:15,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:16,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:17,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:18,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:19,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:20,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:20,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:21,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:22,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:23,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:55:23,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:55:23,858 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:24,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:25,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:25,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:26,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:27,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:28,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:29,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:30,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:31,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:31,859 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:32,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:32,864 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:55:33,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:34,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:35,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:36,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:37,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:37,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:38,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:55:38,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:55:38,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:39,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:40,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:41,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:42,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:42,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:43,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:44,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:45,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:46,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:47,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:48,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:48,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:49,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:50,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:51,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:52,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:53,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:55:53,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:55:53,861 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:53,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:54,602 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:55:54,603 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:55:54,603 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:55:54,618 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:55:54,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:54,956 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:55:55,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:56,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:56,987 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:55:57,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:58,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:55:59,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:55:59,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:00,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:01,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:02,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:02,869 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:56:03,862 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:04,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:05,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:05,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:06,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:07,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:08,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:56:08,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:56:08,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:09,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:10,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:10,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:11,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:12,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:13,863 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:14,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:15,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:16,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:16,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:17,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:18,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:19,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:20,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:21,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:21,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:22,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:23,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:56:23,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:56:23,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:24,864 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:25,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:26,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:26,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:27,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:28,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:29,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:30,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:31,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:32,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:32,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:32,867 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:56:33,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:34,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:35,865 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:36,866 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:37,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:37,866 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:38,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:56:38,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:56:38,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:39,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:40,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:41,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:42,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:42,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:43,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:44,868 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:45,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:46,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:47,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:48,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:48,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:49,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:50,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:51,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:52,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:53,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:56:53,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:56:53,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:53,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:54,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:55,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:56,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:57,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:58,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:56:59,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:56:59,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:00,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:01,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:02,870 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:57:02,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:03,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:04,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:04,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:05,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:06,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:07,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:08,787 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:57:08,787 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:57:08,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:09,546 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:57:09,547 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:57:09,547 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:57:09,566 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:57:09,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:10,233 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:57:10,567 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:10,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:11,248 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:57:11,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:12,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:13,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:14,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:15,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:15,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:16,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:17,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:18,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:19,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:20,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:20,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:21,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:22,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:23,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:57:23,788 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:57:23,872 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:24,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:25,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:25,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:26,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:27,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:28,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:29,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:30,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:31,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:31,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:32,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:32,874 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:57:33,873 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:34,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:35,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:36,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:37,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:37,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:38,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:57:38,788 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:57:38,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:39,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:40,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:41,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:42,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:42,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:43,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:44,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:45,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:46,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:47,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:48,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:48,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:49,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:50,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:51,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:52,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:53,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:57:53,788 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:57:53,875 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:53,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:54,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:55,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:56,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:57,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:58,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:57:59,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:57:59,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:00,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:01,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:02,872 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:58:02,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:03,876 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:04,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:04,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:05,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:06,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:07,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:08,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:58:08,788 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:58:08,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:09,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:09,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:10,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:11,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:12,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:13,877 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:14,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:15,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:15,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:16,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:17,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:18,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:19,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:20,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:20,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:21,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:22,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:23,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:58:23,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:58:23,878 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:24,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:25,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:58:25,175 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:58:25,176 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:58:25,193 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:58:25,540 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:58:25,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:26,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:26,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:27,570 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:58:27,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:28,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:29,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:30,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:31,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:31,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:32,874 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:58:32,879 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:33,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:34,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:35,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:36,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:37,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:37,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:38,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:58:38,788 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:58:38,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:39,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:40,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:41,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:42,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:42,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:43,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:44,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:45,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:46,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:47,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:48,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:48,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:49,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:50,881 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:51,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:52,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:53,788 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:58:53,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:58:53,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:53,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:54,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:55,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:56,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:57,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:58,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:58:59,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:58:59,882 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:00,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:01,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:02,877 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:59:02,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:03,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:04,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:05,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:05,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:06,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:07,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:08,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:59:08,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:59:08,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:09,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:10,883 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:10,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:11,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:12,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:13,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:14,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:15,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:16,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:16,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:17,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:18,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:19,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:20,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:21,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:21,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:22,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:23,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:59:23,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:59:23,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:24,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:25,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:26,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:26,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:27,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:28,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:29,885 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:30,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:31,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:32,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:32,883 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 03:59:32,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:33,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:34,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:35,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:36,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:37,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:38,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:59:38,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:59:38,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:38,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:39,886 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:40,434 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 03:59:40,435 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 03:59:40,435 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 03:59:40,450 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 03:59:40,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:40,899 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 03:59:41,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:42,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:42,931 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 03:59:43,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:44,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:44,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:45,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:46,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:47,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:48,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:49,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:49,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:50,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:51,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:52,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:53,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 03:59:53,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 03:59:53,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:54,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:54,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 03:59:55,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:56,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:57,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:58,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 03:59:59,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:00,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:00,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:01,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:02,880 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:00:02,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:03,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:04,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:05,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:06,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:06,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:07,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:08,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:00:08,789 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:00:08,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:09,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:10,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:11,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:11,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:12,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:13,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:14,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:15,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:16,890 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:17,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:17,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:18,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:19,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:20,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:21,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:22,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:22,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:23,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:00:23,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:00:23,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:24,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:25,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:26,891 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:27,892 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:27,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:28,892 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:29,892 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:30,892 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:31,892 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:32,883 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:00:32,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:33,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:33,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:34,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:35,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:36,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:37,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:38,789 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:00:38,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:00:38,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:38,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:39,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:40,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:41,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:42,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:43,893 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:44,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:44,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:45,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:46,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:47,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:48,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:49,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:50,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:50,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:51,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:52,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:53,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:00:53,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:00:53,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:54,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:55,650 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:00:55,651 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:00:55,652 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:00:55,662 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:00:55,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:56,378 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:00:56,663 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:00:56,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:57,407 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:00:57,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:58,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:00:59,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:00,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:01,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:01,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:02,886 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:01:02,895 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:03,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:04,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:05,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:06,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:07,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:07,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:08,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:01:08,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:01:08,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:09,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:10,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:11,896 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:12,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:12,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:13,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:14,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:15,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:16,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:17,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:18,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:18,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:19,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:20,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:21,897 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:22,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:23,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:01:23,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:01:23,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:23,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:24,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:25,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:26,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:27,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:28,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:29,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:29,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:30,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:31,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:32,884 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:01:32,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:33,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:34,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:35,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:35,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:36,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:37,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:38,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:01:38,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:01:38,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:39,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:40,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:40,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:41,900 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:42,900 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:43,899 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:44,900 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:45,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:46,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:46,900 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:47,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:48,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:49,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:50,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:51,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:51,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:52,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:53,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:01:53,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:01:53,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:54,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:55,901 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:56,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:56,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:01:57,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:58,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:01:59,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:00,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:01,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:02,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:02,887 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:02:02,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:03,902 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:04,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:05,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:06,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:07,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:08,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:02:08,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:02:08,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:08,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:09,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:10,498 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:02:10,499 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:02:10,499 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:02:10,510 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:02:10,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:10,933 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:02:11,904 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:12,903 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:12,971 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:02:13,904 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:14,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:14,904 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:15,906 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:16,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:17,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:18,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:19,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:20,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:20,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:21,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:22,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:23,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:02:23,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:02:23,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:24,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:25,907 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:25,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:26,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:27,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:28,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:29,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:30,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:31,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:31,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:32,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:32,922 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:02:33,908 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:34,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:35,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:36,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:37,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:37,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:38,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:02:38,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:02:38,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:39,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:40,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:41,909 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:42,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:42,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:43,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:44,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:45,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:46,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:47,910 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:48,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:48,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:49,918 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:50,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:51,918 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:52,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:53,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:02:53,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:02:53,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:53,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:54,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:55,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:56,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:57,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:58,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:02:59,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:02:59,919 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:00,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:01,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:02,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:02,932 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:03:03,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:04,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:05,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:05,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:06,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:07,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:08,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:03:08,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:03:08,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:09,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:10,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:10,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:11,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:12,920 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:13,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:14,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:15,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:16,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:16,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:17,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:18,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:19,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:20,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:21,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:21,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:22,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:23,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:03:23,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:03:23,921 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:24,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:25,606 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:03:25,607 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:03:25,608 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:03:25,620 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:03:25,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:26,295 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:03:26,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:27,327 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:03:27,621 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:27,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:28,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:29,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:30,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:31,922 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:32,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:32,922 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:03:32,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:33,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:34,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:35,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:36,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:37,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:37,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:38,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:03:38,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:03:38,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:39,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:40,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:41,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:42,924 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:42,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:43,923 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:44,924 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:45,924 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:46,924 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:47,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:48,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:48,924 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:49,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:50,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:51,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:52,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:53,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:03:53,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:03:53,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:53,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:54,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:55,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:56,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:57,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:58,925 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:03:59,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:03:59,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:00,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:01,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:02,926 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:04:02,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:03,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:04,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:05,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:05,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:06,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:07,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:08,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:04:08,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:04:08,926 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:09,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:10,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:10,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:11,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:12,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:13,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:14,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:15,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:16,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:16,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:17,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:18,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:19,927 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:20,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:21,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:21,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:22,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:23,791 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:04:23,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:04:23,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:24,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:25,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:26,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:26,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:27,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:28,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:29,928 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:30,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:31,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:32,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:32,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:32,935 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:04:33,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:34,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:35,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:36,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:37,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:38,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:04:38,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:04:38,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:38,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:39,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:40,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:04:40,351 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:04:40,351 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:04:40,367 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:04:40,609 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:04:40,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:41,626 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:04:41,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:42,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:43,669 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:04:43,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:44,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:44,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:45,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:46,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:47,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:48,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:49,799 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:49,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:50,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:51,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:52,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:53,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:04:53,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:04:53,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:54,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:54,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:04:55,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:56,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:57,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:58,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:04:59,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:00,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:00,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:01,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:02,928 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:05:02,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:03,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:04,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:05,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:06,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:06,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:07,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:08,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:05:08,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:05:08,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:09,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:10,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:11,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:11,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:12,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:13,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:14,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:15,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:16,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:17,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:17,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:18,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:19,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:20,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:21,939 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:22,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:22,939 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:23,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:05:23,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:05:23,939 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:24,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:25,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:26,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:27,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:27,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:28,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:29,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:30,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:31,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:32,931 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:05:32,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:33,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:33,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:34,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:35,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:36,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:37,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:38,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:05:38,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:05:38,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:38,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:39,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:40,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:41,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:42,941 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:43,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:44,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:44,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:45,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:46,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:47,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:48,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:49,800 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:49,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:50,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:51,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:52,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:53,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:05:53,792 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:05:53,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:54,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:54,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:05:55,390 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:05:55,391 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:05:55,391 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:05:55,403 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:05:55,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:55,975 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:05:56,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:56,994 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:05:57,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:58,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:05:59,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:00,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:00,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:01,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:02,931 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:06:02,943 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:03,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:04,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:05,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:06,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:06,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:07,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:08,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:06:08,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:06:08,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:09,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:10,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:11,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:11,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:12,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:13,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:14,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:15,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:16,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:17,801 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:17,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:18,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:19,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:20,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:21,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:22,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:23,792 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:06:23,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:06:23,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:23,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:24,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:25,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:26,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:27,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:28,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:29,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:29,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:30,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:31,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:32,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:32,991 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:06:33,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:34,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:35,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:35,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:36,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:37,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:38,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:06:38,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:06:38,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:39,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:40,947 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:40,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:41,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:42,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:43,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:44,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:45,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:46,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:46,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:47,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:48,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:49,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:50,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:51,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:51,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:52,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:53,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:06:53,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:06:53,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:54,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:55,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:56,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:56,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:06:57,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:58,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:06:59,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:00,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:01,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:02,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:02,934 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:07:02,949 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:03,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:04,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:05,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:06,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:07,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:07,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:08,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:07:08,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:07:08,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:09,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:07:09,947 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:07:09,947 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:07:09,950 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:10,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:11,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:12,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:13,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:14,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:15,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:16,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:17,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:18,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:19,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:20,951 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:21,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:22,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:23,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:07:23,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:24,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:25,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:26,747 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:07:26,748 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:07:26,748 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:26,779 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:07:26,779 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:07:26,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:27,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:28,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:29,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:30,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:31,860 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:31,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:32,936 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:07:32,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:33,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:34,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:35,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:36,937 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:36,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:37,195 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:07:37,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:38,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:07:38,793 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:07:38,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:39,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:40,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:41,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:41,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:42,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:43,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:44,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:45,954 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:46,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:46,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:47,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:48,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:49,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:50,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:51,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:51,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:52,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:53,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:07:53,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:07:53,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:54,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:55,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:56,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:56,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:07:57,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:58,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:07:59,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:00,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:01,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:01,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:02,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:02,971 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:08:03,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:04,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:05,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:06,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:06,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:07,956 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:08,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:08:08,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:08:08,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:09,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:10,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:11,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:12,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:12,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:13,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:14,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:15,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:16,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:17,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:17,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:18,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:19,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:20,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:21,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:22,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:22,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:23,793 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:08:23,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:08:23,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:24,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:08:24,415 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:08:24,415 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:08:24,433 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:08:24,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:25,360 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:08:25,360 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:08:25,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:26,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:27,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:28,434 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:28,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:29,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:30,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:31,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:32,939 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:08:32,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:33,940 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:33,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:34,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:35,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:36,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:37,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:38,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:08:38,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:08:38,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:38,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:39,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:40,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:41,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:42,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:43,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:43,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:44,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:45,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:46,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:47,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:48,960 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:48,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:49,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:50,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:51,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:52,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:53,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:08:53,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:08:53,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:54,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:54,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:08:55,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:56,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:57,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:58,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:59,961 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:08:59,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:00,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:01,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:02,941 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:09:02,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:03,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:04,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:05,942 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:05,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:06,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:07,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:08,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:09:08,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:09:08,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:09,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:10,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:10,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:11,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:12,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:13,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:14,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:15,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:15,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:16,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:17,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:18,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:19,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:20,963 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:20,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:21,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:22,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:23,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:09:23,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:09:23,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:24,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:25,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:25,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:26,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:27,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:28,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:29,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:30,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:30,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:31,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:32,942 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:09:32,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:33,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:34,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:35,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:36,944 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:36,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:37,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:38,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:09:38,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:09:38,880 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:09:38,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:38,970 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:09:38,970 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:09:39,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:40,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:41,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:42,965 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:43,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:44,776 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:09:44,782 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:09:44,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:45,051 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:09:45,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:45,805 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:09:45,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:46,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:47,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:48,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:49,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:50,543 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:50,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:51,966 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:52,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:53,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:09:53,794 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:09:53,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:54,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:55,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:55,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:09:56,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:57,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:58,103 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:09:58,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:09:59,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:00,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:00,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:01,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:02,944 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:10:02,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:03,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:04,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:05,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:06,945 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:06,968 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:07,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:08,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:10:08,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:10:08,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:09,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:10,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:11,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:11,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:12,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:13,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:14,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:15,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:16,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:16,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:17,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:18,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:19,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:20,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:21,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:21,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:22,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:23,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:10:23,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:10:23,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:24,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:25,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:26,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:27,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:27,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:28,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:29,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:30,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:31,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:32,945 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:10:32,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:33,946 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:33,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:34,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:35,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:36,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:37,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:38,794 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:10:38,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:10:38,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:38,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:39,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:40,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:41,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:42,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:43,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:43,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:44,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:45,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:46,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:47,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:48,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:48,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:49,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:50,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:51,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:52,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:53,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:10:53,311 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:10:53,311 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:10:53,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:10:53,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:54,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:55,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:56,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:57,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:58,816 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:10:58,817 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:10:58,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:10:58,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:10:59,857 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:10:59,857 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:10:59,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:00,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:01,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:02,947 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:11:02,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:03,948 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:03,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:04,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:05,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:06,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:07,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:08,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:11:08,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:11:08,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:08,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:09,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:10,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:11,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:12,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:13,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:13,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:14,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:15,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:16,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:17,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:18,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:18,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:19,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:20,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:21,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:22,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:23,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:11:23,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:11:23,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:24,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:24,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:25,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:26,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:27,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:28,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:29,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:29,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:30,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:31,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:32,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:33,005 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:11:33,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:34,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:35,006 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:35,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:36,977 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:37,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:38,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:11:38,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:11:38,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:39,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:40,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:40,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:41,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:42,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:43,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:44,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:45,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:45,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:46,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:47,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:48,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:49,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:50,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:50,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:51,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:52,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:53,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:11:53,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:11:53,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:54,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:55,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:56,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:11:56,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:57,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:58,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:11:59,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:00,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:01,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:01,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:02,949 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:12:02,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:03,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:04,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:05,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:06,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:07,608 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:07,650 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:12:07,651 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:12:07,651 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:12:07,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:08,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:12:08,980 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:09,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:10,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:11,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:12,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:13,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:14,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:15,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:16,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:17,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:18,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:19,981 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:20,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:21,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:22,969 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:12:22,970 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:12:22,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:22,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:23,027 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:12:23,027 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:12:23,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:12:23,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:12:23,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:24,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:25,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:26,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:27,011 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:12:27,011 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:12:27,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:27,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:28,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:29,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:30,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:31,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:32,951 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:12:32,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:33,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:33,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:34,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:35,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:36,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:37,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:38,795 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:12:38,795 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:12:38,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:38,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:39,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:40,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:41,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:42,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:43,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:43,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:44,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:45,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:46,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:47,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:48,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:48,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:49,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:50,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:51,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:52,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:53,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:12:53,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:12:53,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:53,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:54,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:55,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:56,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:57,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:58,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:12:58,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:12:59,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:00,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:01,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:02,954 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:13:02,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:03,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:04,955 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:04,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:05,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:06,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:07,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:08,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:13:08,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:13:08,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:09,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:09,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:10,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:11,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:12,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:13,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:14,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:14,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:15,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:16,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:17,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:18,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:19,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:19,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:20,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:21,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:22,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:13:22,069 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:13:22,070 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:13:22,079 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:13:22,774 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:13:22,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:23,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:13:23,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:13:23,798 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:13:23,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:24,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:25,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:25,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:26,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:27,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:28,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:29,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:30,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:30,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:31,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:32,955 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:13:32,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:33,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:34,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:35,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:36,957 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:36,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:37,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:38,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:13:38,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:13:38,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:39,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:40,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:41,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:41,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:42,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:43,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:44,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:45,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:46,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:46,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:47,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:48,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:49,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:50,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:51,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:51,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:52,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:53,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:13:53,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:13:53,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:54,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:55,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:56,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:57,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:13:57,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:58,990 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:13:59,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:00,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:01,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:02,957 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:14:02,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:03,958 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:03,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:04,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:05,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:06,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:07,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:08,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:14:08,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:14:08,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:08,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:09,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:10,991 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:11,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:12,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:13,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:13,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:14,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:15,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:16,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:17,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:18,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:18,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:19,992 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:20,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:21,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:22,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:23,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:14:23,796 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:14:23,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:24,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:24,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:25,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:26,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:27,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:28,993 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:29,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:29,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:30,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:31,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:32,958 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:14:32,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:33,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:34,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:35,959 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:35,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:36,718 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:14:36,719 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:14:36,719 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:14:36,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:37,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:38,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:14:38,994 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:39,995 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:40,768 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:14:40,776 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:14:40,995 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:41,287 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:14:41,288 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:14:41,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:41,793 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:14:42,006 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:43,006 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:43,861 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:14:44,006 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:45,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:46,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:46,464 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:47,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:48,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:49,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:50,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:51,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:51,464 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:52,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:53,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:53,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:14:53,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:14:54,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:55,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:56,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:56,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:14:57,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:58,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:14:59,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:00,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:01,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:01,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:02,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:02,962 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:15:03,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:04,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:05,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:06,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:07,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:07,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:08,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:08,796 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:15:08,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:15:09,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:10,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:11,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:12,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:12,971 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:13,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:14,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:15,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:16,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:17,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:17,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:18,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:19,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:20,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:21,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:22,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:22,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:23,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:23,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:15:23,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:15:24,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:25,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:26,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:27,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:27,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:28,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:29,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:30,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:31,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:32,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:32,961 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:15:33,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:33,962 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:34,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:35,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:36,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:37,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:38,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:38,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:15:38,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:15:38,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:39,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:40,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:41,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:42,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:43,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:43,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:44,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:45,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:46,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:47,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:48,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:48,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:49,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:50,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:51,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:51,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:15:51,175 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:15:51,175 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:15:51,302 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:15:51,661 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:15:52,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:53,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:53,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:15:53,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:15:54,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:54,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:15:55,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:56,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:57,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:58,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:59,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:15:59,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:00,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:01,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:02,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:02,963 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:16:03,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:04,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:05,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:05,964 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:06,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:07,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:08,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:08,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:16:08,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:16:09,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:10,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:10,740 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:16:10,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:11,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:12,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:13,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:14,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:15,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:15,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:16,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:17,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:18,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:19,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:20,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:20,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:21,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:22,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:23,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:23,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:16:23,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:16:24,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:25,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:26,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:26,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:27,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:28,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:29,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:30,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:31,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:31,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:32,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:32,968 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:16:33,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:34,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:35,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:36,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:37,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:37,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:38,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:38,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:16:38,797 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:16:39,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:40,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:41,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:42,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:42,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:43,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:44,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:45,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:46,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:47,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:47,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:48,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:49,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:50,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:51,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:52,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:52,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:53,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:53,797 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:16:53,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:16:54,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:55,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:56,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:57,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:58,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:16:58,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:16:59,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:00,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:01,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:02,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:02,966 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:17:03,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:04,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:04,967 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:05,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:05,754 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:17:05,755 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:17:05,755 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:17:05,842 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:17:06,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:06,707 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:17:07,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:07,760 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:17:08,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:08,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:17:08,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:17:09,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:09,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:10,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:11,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:12,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:13,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:14,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:14,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:15,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:16,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:17,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:18,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:19,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:19,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:20,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:21,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:22,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:23,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:23,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:17:23,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:17:24,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:25,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:25,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:26,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:27,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:28,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:29,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:30,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:30,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:31,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:32,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:32,967 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:17:33,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:34,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:35,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:36,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:36,969 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:37,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:38,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:38,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:17:38,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:17:39,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:40,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:41,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:41,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:42,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:43,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:44,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:45,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:46,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:46,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:47,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:48,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:49,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:50,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:51,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:51,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:52,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:53,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:53,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:17:53,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:17:54,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:55,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:56,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:57,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:57,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:17:58,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:17:59,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:00,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:01,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:02,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:02,969 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:18:03,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:03,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:04,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:05,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:06,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:07,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:08,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:08,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:18:08,798 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:18:08,972 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:09,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:10,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:11,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:12,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:13,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:13,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:14,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:15,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:16,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:17,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:18,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:18,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:19,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:20,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:20,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:18:20,379 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:18:20,379 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:18:21,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:22,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:23,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:23,798 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: stop_status +2024-07-21 04:18:24,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:25,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:26,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:27,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:28,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:29,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:30,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:31,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:32,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:33,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:34,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:35,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:36,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:37,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:38,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:39,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:40,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:41,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:42,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:43,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:44,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:44,087 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:18:44,095 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:18:44,446 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:18:44,446 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: stop_status +2024-07-21 04:18:44,446 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:44,622 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:18:45,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:45,116 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:18:46,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:46,133 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:18:47,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:48,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:49,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:49,624 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:50,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:51,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:52,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:53,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:54,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:54,624 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:18:55,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:56,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:57,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:58,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:59,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:18:59,625 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:00,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:01,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:02,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:02,972 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:19:03,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:04,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:04,973 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:05,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:06,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:07,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:08,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:09,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:09,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:10,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:11,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:12,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:13,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:14,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:14,974 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:15,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:16,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:17,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:18,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:19,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:19,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:20,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:21,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:22,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:23,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:24,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:24,975 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:25,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:26,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:27,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:28,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:29,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:29,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:30,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:31,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:32,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:32,975 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:19:33,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:34,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:34,976 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:35,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:35,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:19:35,187 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:19:35,187 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:19:36,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:37,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:38,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:39,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:40,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:41,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:42,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:43,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:44,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:45,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:46,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:47,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:48,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:49,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:50,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:51,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:52,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:53,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:54,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:55,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:55,072 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:19:55,082 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:19:55,228 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:19:55,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:19:56,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:56,097 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:19:57,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:58,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:19:59,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:00,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:00,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:01,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:02,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:03,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:04,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:04,618 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:20:04,683 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:20:05,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:05,684 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:06,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:07,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:08,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:09,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:10,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:10,685 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:11,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:12,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:13,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:14,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:15,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:15,685 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:16,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:17,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:18,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:19,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:20,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:20,686 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:21,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:22,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:23,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:24,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:25,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:25,686 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:26,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:27,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:28,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:29,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:30,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:30,687 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:31,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:32,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:32,977 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:20:33,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:34,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:35,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:35,978 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:36,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:37,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:38,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:39,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:40,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:40,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:41,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:42,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:43,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:44,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:45,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:45,979 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:20:46,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:47,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:48,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:49,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:49,518 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:20:49,519 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:20:49,519 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:20:50,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:51,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:52,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:53,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:54,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:55,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:56,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:57,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:58,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:20:59,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:00,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:01,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:01,917 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:21:01,921 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:21:02,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:03,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:04,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:05,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:06,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:07,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:08,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:09,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:10,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:11,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:12,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:13,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:14,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:15,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:16,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:17,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:18,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:19,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:20,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:21,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:22,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:23,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:23,353 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:21:23,392 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:21:23,392 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:24,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:25,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:26,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:27,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:27,542 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:21:27,542 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:21:28,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:28,394 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:29,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:30,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:31,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:32,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:32,980 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:21:33,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:33,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:34,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:35,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:36,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:37,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:38,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:38,982 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:39,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:40,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:41,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:42,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:43,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:43,983 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:44,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:45,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:46,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:47,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:48,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:48,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:49,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:50,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:51,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:52,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:53,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:53,984 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:54,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:55,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:56,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:57,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:58,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:21:58,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:21:59,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:00,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:01,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:02,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:03,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:03,786 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:22:03,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:04,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:05,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:06,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:07,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:08,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:08,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:09,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:10,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:11,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:12,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:13,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:13,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:14,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:15,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:16,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:17,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:18,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:18,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:19,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:20,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:21,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:22,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:23,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:23,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:24,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:25,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:26,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:27,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:28,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:28,988 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:29,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:30,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:31,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:32,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:33,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:33,989 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:34,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:35,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:36,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:37,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:38,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:38,155 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:22:38,156 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:22:38,157 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:22:38,206 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:22:38,206 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:22:38,895 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:22:39,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:39,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:39,922 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:22:40,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:41,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:42,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:43,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:44,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:44,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:45,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:46,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:47,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:48,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:49,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:49,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:50,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:51,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:52,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:53,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:54,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:54,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:22:55,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:56,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:57,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:58,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:59,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:22:59,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:00,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:01,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:02,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:02,984 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:23:03,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:04,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:04,985 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:05,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:06,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:07,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:08,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:09,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:09,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:10,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:11,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:12,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:13,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:14,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:14,987 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:15,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:16,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:17,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:18,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:18,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:23:18,247 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:23:18,248 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:23:19,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:20,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:21,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:22,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:23,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:24,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:25,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:26,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:26,106 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:23:26,109 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:23:26,148 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:23:26,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:27,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:27,193 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:23:28,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:28,208 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:23:29,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:30,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:31,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:31,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:32,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:33,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:34,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:35,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:36,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:36,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:37,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:38,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:39,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:40,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:41,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:41,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:42,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:43,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:44,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:45,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:46,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:46,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:47,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:48,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:49,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:50,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:51,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:51,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:52,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:53,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:54,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:55,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:56,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:56,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:23:57,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:58,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:23:59,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:00,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:01,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:01,153 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:02,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:03,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:04,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:05,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:06,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:06,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:07,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:08,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:09,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:10,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:11,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:11,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:12,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:13,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:14,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:15,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:16,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:16,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:17,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:18,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:19,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:20,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:21,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:21,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:22,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:23,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:24,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:25,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:26,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:26,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:27,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:28,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:29,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:30,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:31,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:31,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:32,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:32,678 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:24:33,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:34,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:35,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:36,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:36,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:37,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:38,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:39,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:40,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:41,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:41,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:42,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:43,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:44,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:45,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:46,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:46,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:47,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:48,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:49,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:50,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:51,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:51,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:52,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:53,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:54,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:55,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:56,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:56,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:24:57,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:58,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:24:59,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:00,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:01,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:01,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:02,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:03,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:04,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:05,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:06,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:06,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:07,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:08,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:09,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:10,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:11,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:11,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:12,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:13,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:14,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:15,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:16,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:16,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:17,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:18,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:19,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:20,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:21,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:21,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:22,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:23,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:23,347 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:25:23,350 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:25:23,350 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:25:23,351 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:25:23,506 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:25:23,507 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:25:23,507 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:25:24,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:24,557 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:25:25,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:26,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:26,508 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:26,604 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:25:27,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:28,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:29,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:30,074 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:31,074 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:31,509 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:32,074 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:33,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:34,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:35,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:36,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:36,510 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:37,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:38,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:39,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:40,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:41,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:41,510 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:42,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:43,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:44,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:45,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:46,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:46,511 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:47,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:47,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:25:48,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:49,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:50,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:51,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:51,512 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:52,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:53,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:54,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:55,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:56,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:56,512 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:25:57,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:58,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:25:59,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:00,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:01,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:01,513 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:02,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:03,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:04,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:05,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:06,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:06,514 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:07,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:08,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:09,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:10,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:11,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:11,514 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:12,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:13,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:14,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:15,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:16,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:16,515 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:17,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:18,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:19,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:20,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:21,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:21,515 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:22,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:23,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:24,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:25,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:26,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:26,516 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:27,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:28,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:29,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:30,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:31,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:31,517 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:32,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:33,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:34,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:35,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:36,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:36,517 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:37,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:38,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:39,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:40,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:41,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:41,518 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:42,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:43,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:44,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:45,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:45,904 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:26:45,905 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:26:45,907 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:26:45,949 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:26:45,949 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:26:45,950 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:26:46,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:46,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:46,965 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:26:47,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:47,997 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:26:48,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:49,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:50,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:51,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:51,952 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:52,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:53,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:54,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:55,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:56,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:56,953 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:26:57,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:58,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:26:59,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:00,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:01,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:01,626 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:27:01,627 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:27:01,627 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:27:02,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:03,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:04,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:05,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:06,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:07,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:08,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:09,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:10,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:11,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:12,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:13,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:14,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:15,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:16,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:17,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:18,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:18,316 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:27:18,436 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:27:18,436 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:27:18,437 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:19,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:19,378 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:27:20,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:20,409 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:27:21,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:22,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:23,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:23,438 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:24,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:25,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:26,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:27,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:28,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:28,438 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:29,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:30,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:31,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:32,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:32,999 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:27:33,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:34,000 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:34,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:35,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:36,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:37,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:38,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:39,001 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:39,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:40,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:41,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:42,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:43,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:44,001 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:44,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:45,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:46,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:47,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:48,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:49,002 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:49,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:50,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:51,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:52,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:53,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:54,003 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:54,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:55,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:56,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:57,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:58,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:27:59,003 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:27:59,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:00,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:01,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:02,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:03,002 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:28:03,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:04,003 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:04,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:05,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:06,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:07,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:08,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:09,004 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:09,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:10,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:11,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:12,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:13,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:14,005 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:14,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:15,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:16,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:28:16,087 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:28:16,087 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:28:16,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:17,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:17,482 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:28:18,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:19,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:20,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:21,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:22,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:23,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:24,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:25,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:26,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:27,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:28,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:28,879 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:28:29,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:30,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:31,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:32,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:33,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:34,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:35,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:35,928 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:28:35,929 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:28:35,929 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:36,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:36,379 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:28:37,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:38,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:38,534 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:28:39,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:40,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:40,930 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:41,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:42,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:43,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:44,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:45,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:45,931 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:46,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:47,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:48,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:49,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:50,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:50,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:51,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:52,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:53,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:54,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:55,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:55,932 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:28:56,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:57,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:58,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:28:59,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:00,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:00,933 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:01,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:02,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:03,006 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:29:03,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:04,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:05,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:06,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:06,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:07,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:08,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:09,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:10,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:11,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:11,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:12,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:13,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:14,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:15,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:16,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:16,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:17,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:18,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:19,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:20,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:21,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:21,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:22,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:23,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:24,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:25,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:26,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:26,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:27,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:28,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:29,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:30,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:30,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:29:30,971 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:29:30,972 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:29:30,985 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:29:31,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:31,106 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:29:31,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:32,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:32,123 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:29:33,006 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:29:33,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:34,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:35,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:36,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:37,007 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:37,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:38,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:39,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:40,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:41,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:42,008 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:42,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:43,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:44,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:45,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:46,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:47,009 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:47,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:48,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:49,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:50,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:51,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:52,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:52,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:53,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:54,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:55,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:56,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:57,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:29:57,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:58,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:29:59,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:00,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:01,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:02,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:02,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:03,009 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:30:03,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:04,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:05,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:06,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:07,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:08,010 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:08,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:09,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:10,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:11,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:12,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:13,011 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:13,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:14,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:15,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:16,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:17,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:18,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:18,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:19,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:20,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:21,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:22,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:23,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:23,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:24,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:25,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:26,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:27,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:28,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:28,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:29,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:30,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:31,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:32,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:33,012 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:30:33,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:34,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:34,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:35,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:36,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:37,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:38,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:39,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:39,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:40,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:41,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:42,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:43,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:44,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:44,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:45,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:45,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:30:45,791 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:30:45,791 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:30:45,802 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:30:46,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:46,560 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:30:47,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:48,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:48,596 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:30:49,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:49,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:50,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:51,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:52,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:53,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:54,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:54,803 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:30:55,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:56,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:57,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:58,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:59,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:30:59,804 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:00,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:01,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:02,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:03,010 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:31:03,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:04,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:05,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:05,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:06,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:07,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:08,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:09,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:10,012 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:10,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:11,110 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:12,110 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:13,110 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:14,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:15,013 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:15,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:16,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:17,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:18,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:19,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:20,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:20,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:21,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:22,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:23,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:24,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:25,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:25,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:26,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:27,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:28,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:29,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:30,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:30,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:31,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:32,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:33,013 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:31:33,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:34,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:35,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:36,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:36,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:37,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:38,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:39,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:40,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:41,015 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:41,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:42,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:43,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:44,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:45,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:46,016 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:46,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:47,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:48,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:49,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:50,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:51,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:51,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:52,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:53,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:54,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:55,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:56,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:31:56,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:57,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:58,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:31:59,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:00,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:00,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:32:00,331 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:32:00,331 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:32:00,342 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:32:00,968 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:32:01,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:01,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:01,985 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:32:02,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:03,016 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:32:03,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:04,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:05,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:06,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:07,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:07,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:08,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:09,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:10,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:11,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:12,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:12,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:13,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:14,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:15,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:16,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:17,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:17,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:18,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:19,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:20,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:21,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:22,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:22,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:23,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:24,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:25,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:26,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:27,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:27,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:28,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:29,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:30,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:31,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:32,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:32,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:33,015 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:32:33,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:34,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:35,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:36,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:37,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:38,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:38,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:39,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:40,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:41,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:42,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:43,017 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:43,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:44,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:45,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:46,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:47,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:48,018 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:48,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:49,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:50,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:51,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:52,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:53,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:53,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:54,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:55,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:56,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:57,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:58,019 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:32:58,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:32:59,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:00,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:01,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:02,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:03,019 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:33:03,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:03,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:04,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:05,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:06,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:07,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:08,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:08,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:09,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:10,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:11,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:12,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:13,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:13,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:14,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:15,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:15,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:33:15,195 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:33:15,195 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:33:15,207 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:33:15,398 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:33:16,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:16,420 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:33:17,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:18,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:18,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:19,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:20,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:21,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:22,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:23,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:23,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:24,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:25,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:26,135 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:27,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:28,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:28,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:29,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:30,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:31,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:32,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:33,019 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:33:33,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:34,020 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:34,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:35,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:36,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:37,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:38,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:39,021 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:39,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:40,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:41,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:42,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:43,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:44,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:44,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:45,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:46,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:47,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:48,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:49,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:49,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:50,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:51,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:52,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:53,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:54,023 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:54,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:55,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:56,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:57,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:58,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:33:59,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:33:59,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:00,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:01,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:02,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:03,023 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:34:03,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:04,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:04,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:05,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:06,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:07,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:08,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:09,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:09,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:10,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:11,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:12,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:13,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:14,026 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:14,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:15,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:16,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:17,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:18,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:19,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:19,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:20,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:21,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:22,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:23,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:24,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:24,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:25,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:26,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:27,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:28,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:29,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:29,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:29,970 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:34:29,971 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:34:29,971 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:34:29,981 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:34:30,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:30,856 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:34:30,856 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:34:31,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:32,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:32,889 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:34:33,023 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:34:33,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:34,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:35,024 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:35,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:36,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:37,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:38,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:39,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:40,025 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:40,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:41,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:42,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:43,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:44,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:45,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:45,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:46,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:47,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:48,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:49,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:50,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:50,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:51,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:52,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:53,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:54,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:55,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:34:55,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:56,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:57,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:58,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:34:59,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:00,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:00,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:01,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:02,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:03,026 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:35:03,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:04,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:05,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:06,027 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:06,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:07,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:08,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:09,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:10,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:11,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:11,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:12,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:13,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:14,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:15,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:16,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:16,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:17,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:18,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:19,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:20,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:21,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:21,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:22,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:23,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:24,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:25,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:26,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:26,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:27,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:28,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:29,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:30,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:31,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:31,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:32,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:33,033 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:35:33,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:34,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:35,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:36,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:36,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:37,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:38,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:39,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:40,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:41,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:41,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:42,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:43,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:44,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:44,582 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:35:44,583 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:35:44,583 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:35:44,594 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:35:45,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:45,154 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:35:46,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:46,169 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:35:46,616 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:47,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:48,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:49,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:50,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:51,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:51,617 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:52,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:53,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:54,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:55,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:56,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:56,617 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:35:57,153 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:58,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:35:59,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:00,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:01,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:01,618 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:02,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:03,027 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:36:03,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:04,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:05,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:06,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:07,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:07,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:08,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:09,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:10,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:11,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:12,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:12,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:13,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:14,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:15,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:16,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:17,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:17,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:18,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:19,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:20,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:21,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:22,031 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:22,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:23,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:24,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:25,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:26,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:27,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:27,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:28,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:29,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:30,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:31,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:32,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:32,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:33,031 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:36:33,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:34,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:35,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:36,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:37,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:38,032 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:38,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:39,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:40,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:41,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:42,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:43,033 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:43,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:44,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:45,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:46,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:47,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:48,034 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:48,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:49,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:50,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:51,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:52,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:53,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:53,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:54,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:55,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:56,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:57,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:58,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:36:58,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:59,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:36:59,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:36:59,239 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:36:59,239 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:36:59,253 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:36:59,528 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:37:00,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:00,543 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:37:01,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:02,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:03,033 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:37:03,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:04,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:04,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:05,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:06,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:07,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:08,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:09,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:09,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:10,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:11,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:12,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:13,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:14,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:14,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:15,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:16,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:17,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:18,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:19,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:19,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:20,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:21,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:22,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:23,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:24,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:24,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:25,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:26,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:27,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:28,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:29,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:29,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:30,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:31,163 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:32,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:33,033 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:37:33,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:34,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:35,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:35,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:36,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:37,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:38,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:39,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:40,035 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:40,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:41,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:42,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:43,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:44,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:45,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:45,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:46,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:47,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:48,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:49,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:50,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:50,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:51,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:52,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:53,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:54,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:55,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:37:55,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:56,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:57,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:58,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:37:59,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:00,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:00,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:01,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:02,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:03,034 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:38:03,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:04,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:05,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:06,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:06,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:07,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:08,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:09,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:10,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:11,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:11,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:12,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:13,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:13,734 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:38:13,735 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:38:13,735 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:38:13,750 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:38:13,752 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:38:14,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:14,768 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:38:14,768 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:38:15,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:16,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:16,753 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:17,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:18,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:19,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:20,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:21,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:21,753 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:22,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:23,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:24,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:25,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:26,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:26,754 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:27,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:28,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:29,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:30,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:31,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:31,755 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:32,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:33,036 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:38:33,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:34,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:35,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:36,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:37,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:37,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:38,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:39,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:40,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:41,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:42,038 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:42,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:43,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:44,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:45,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:46,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:47,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:47,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:48,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:49,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:50,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:51,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:52,039 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:52,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:53,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:54,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:55,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:56,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:57,040 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:38:57,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:58,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:38:59,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:00,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:01,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:02,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:02,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:03,040 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:39:03,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:04,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:05,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:06,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:07,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:07,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:08,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:09,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:10,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:11,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:12,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:12,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:13,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:14,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:15,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:16,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:17,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:17,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:18,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:19,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:20,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:21,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:22,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:22,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:23,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:24,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:25,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:26,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:27,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:27,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:28,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:28,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:39:28,307 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:39:28,307 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:39:28,320 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:39:29,046 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:39:29,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:30,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:31,077 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:39:31,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:32,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:32,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:33,039 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:39:33,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:34,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:35,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:36,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:37,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:38,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:38,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:39,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:40,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:41,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:42,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:43,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:43,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:44,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:45,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:46,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:47,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:48,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:48,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:49,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:50,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:51,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:52,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:53,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:53,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:54,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:55,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:56,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:57,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:58,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:39:58,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:39:59,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:00,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:01,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:02,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:03,042 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:40:03,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:04,043 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:04,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:05,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:06,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:07,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:08,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:09,044 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:09,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:10,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:11,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:12,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:13,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:14,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:14,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:15,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:16,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:17,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:18,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:19,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:19,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:20,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:21,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:22,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:23,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:24,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:24,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:25,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:26,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:27,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:28,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:29,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:29,181 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:30,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:31,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:32,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:33,048 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:40:33,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:34,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:34,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:35,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:36,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:37,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:38,182 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:39,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:39,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:40,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:41,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:42,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:42,874 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:40:42,875 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:40:42,875 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:40:42,887 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:40:43,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:43,242 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:40:44,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:44,887 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:45,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:45,272 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:40:46,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:47,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:48,183 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:49,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:49,888 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:50,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:51,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:52,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:53,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:54,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:54,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:40:55,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:56,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:57,184 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:58,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:59,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:40:59,889 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:00,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:01,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:02,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:03,044 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:41:03,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:04,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:05,045 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:05,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:06,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:07,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:08,185 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:09,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:10,046 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:10,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:11,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:12,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:13,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:14,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:15,047 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:15,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:16,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:17,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:18,186 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:19,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:20,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:20,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:21,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:22,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:23,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:24,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:25,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:25,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:26,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:27,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:28,187 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:29,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:30,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:30,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:31,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:32,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:33,047 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:41:33,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:34,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:35,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:36,048 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:36,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:37,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:38,188 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:39,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:40,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:41,049 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:41,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:42,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:43,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:44,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:45,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:46,050 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:46,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:47,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:48,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:49,189 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:50,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:51,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:51,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:52,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:53,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:54,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:55,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:56,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:41:56,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:57,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:57,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:41:57,283 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:41:57,283 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:41:57,336 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:41:57,496 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:41:58,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:41:58,511 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:41:59,190 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:00,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:01,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:01,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:02,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:03,053 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:42:03,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:04,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:05,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:06,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:07,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:07,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:08,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:09,191 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:10,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:11,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:12,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:12,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:13,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:14,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:15,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:16,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:17,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:17,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:18,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:19,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:20,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:21,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:22,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:22,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:23,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:24,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:25,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:26,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:27,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:27,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:28,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:29,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:30,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:31,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:32,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:32,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:33,049 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:42:33,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:34,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:35,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:36,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:37,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:38,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:38,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:39,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:40,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:41,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:42,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:43,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:43,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:44,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:45,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:46,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:47,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:48,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:48,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:49,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:50,195 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:51,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:52,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:53,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:53,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:54,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:55,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:56,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:57,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:58,053 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:42:58,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:42:59,196 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:00,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:01,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:02,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:03,053 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:43:03,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:03,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:04,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:05,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:06,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:07,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:08,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:08,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:09,197 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:10,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:11,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:11,894 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:43:11,895 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:43:11,895 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:43:11,913 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:43:12,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:12,667 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:43:12,667 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:43:13,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:13,913 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:14,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:15,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:16,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:17,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:18,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:18,914 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:19,198 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:20,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:21,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:22,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:23,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:23,915 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:24,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:25,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:26,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:27,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:28,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:28,915 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:29,199 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:30,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:31,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:32,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:33,053 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:43:33,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:34,054 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:34,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:35,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:36,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:37,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:38,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:39,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:39,200 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:40,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:41,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:42,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:43,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:44,055 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:44,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:45,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:46,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:47,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:48,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:49,056 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:49,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:50,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:51,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:52,201 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:53,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:54,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:54,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:55,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:56,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:57,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:58,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:43:59,057 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:43:59,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:00,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:01,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:02,202 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:03,059 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:44:03,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:04,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:04,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:05,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:06,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:07,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:08,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:09,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:09,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:10,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:11,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:12,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:13,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:14,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:14,203 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:15,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:16,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:17,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:18,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:19,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:19,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:20,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:21,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:22,204 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:23,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:24,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:24,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:25,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:26,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:26,642 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:44:26,643 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:44:26,643 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:44:26,657 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:44:26,755 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:44:27,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:28,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:28,786 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:44:29,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:29,657 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:30,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:31,205 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:32,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:33,057 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:44:33,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:34,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:35,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:35,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:36,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:37,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:38,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:39,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:40,058 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:40,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:41,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:42,206 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:43,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:44,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:45,059 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:45,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:46,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:47,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:48,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:49,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:50,060 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:50,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:51,207 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:52,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:53,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:54,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:55,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:44:55,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:56,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:57,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:58,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:44:59,208 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:00,061 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:00,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:01,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:02,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:03,060 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:45:03,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:04,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:05,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:06,062 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:06,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:07,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:08,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:09,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:10,209 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:11,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:11,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:12,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:13,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:14,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:15,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:16,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:16,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:17,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:18,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:19,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:20,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:21,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:21,210 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:22,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:23,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:24,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:25,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:26,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:26,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:27,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:28,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:29,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:30,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:31,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:31,211 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:32,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:33,062 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:45:33,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:34,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:35,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:36,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:37,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:37,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:38,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:39,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:40,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:41,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:45:41,171 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:45:41,171 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:45:41,212 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:42,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:42,588 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:45:42,589 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:42,769 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:45:42,770 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:45:43,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:44,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:45,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:46,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:47,213 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:47,274 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:45:47,589 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:48,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:49,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:50,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:51,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:52,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:52,590 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:53,216 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:54,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:55,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:56,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:57,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:57,591 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:45:58,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:45:59,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:00,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:01,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:02,217 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:02,591 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:03,061 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:46:03,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:04,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:05,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:06,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:07,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:08,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:08,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:09,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:10,218 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:11,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:12,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:13,063 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:13,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:14,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:15,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:16,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:17,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:18,064 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:18,219 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:19,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:20,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:21,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:22,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:23,065 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:23,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:24,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:25,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:26,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:27,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:28,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:28,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:29,220 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:30,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:31,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:32,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:33,065 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:46:33,066 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:33,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:34,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:35,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:36,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:37,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:38,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:38,221 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:39,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:40,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:41,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:42,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:43,067 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:43,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:44,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:45,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:46,222 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:47,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:48,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:48,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:49,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:50,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:51,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:52,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:53,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:53,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:54,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:55,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:55,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:46:55,851 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:46:55,851 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:46:55,868 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:46:56,167 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:46:56,223 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:57,181 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:46:57,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:58,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:46:58,869 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:46:59,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:00,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:01,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:02,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:03,068 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:47:03,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:04,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:04,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:05,224 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:06,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:07,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:08,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:09,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:09,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:10,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:11,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:12,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:13,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:14,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:14,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:15,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:16,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:17,225 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:18,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:19,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:19,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:20,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:21,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:22,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:23,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:24,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:24,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:25,226 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:26,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:27,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:28,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:29,073 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:29,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:30,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:31,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:32,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:33,067 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:47:33,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:34,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:35,068 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:35,227 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:36,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:37,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:38,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:39,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:40,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:40,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:41,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:42,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:43,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:44,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:45,069 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:45,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:46,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:47,228 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:48,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:49,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:50,070 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:50,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:51,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:52,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:53,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:54,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:55,071 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:47:55,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:56,229 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:57,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:58,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:47:59,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:00,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:00,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:01,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:02,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:03,071 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:48:03,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:04,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:05,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:06,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:06,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:07,230 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:08,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:09,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:10,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:10,686 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:48:10,687 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:48:10,687 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:48:10,699 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:48:11,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:11,670 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:48:11,700 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:12,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:12,703 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:48:13,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:14,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:15,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:16,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:16,701 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:17,231 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:18,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:19,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:20,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:21,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:21,701 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:22,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:23,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:24,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:25,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:26,232 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:26,702 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:27,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:28,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:29,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:30,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:31,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:31,702 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:32,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:33,070 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:48:33,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:34,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:35,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:36,233 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:37,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:37,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:38,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:39,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:40,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:41,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:42,072 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:42,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:43,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:44,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:45,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:46,234 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:47,073 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:47,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:48,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:49,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:50,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:51,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:52,074 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:52,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:53,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:54,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:55,235 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:56,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:57,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:48:57,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:58,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:48:59,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:00,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:01,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:02,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:02,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:03,075 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:49:03,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:04,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:05,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:06,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:07,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:07,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:08,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:09,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:10,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:11,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:12,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:12,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:13,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:14,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:15,237 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:16,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:17,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:17,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:18,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:19,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:20,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:21,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:22,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:22,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:23,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:24,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:25,236 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:49:25,237 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:49:25,238 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:49:25,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:25,259 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:49:26,109 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:49:26,238 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:27,134 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:49:27,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:27,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:28,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:29,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:30,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:31,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:32,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:32,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:33,073 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:49:33,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:34,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:35,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:36,239 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:37,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:38,074 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:38,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:39,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:40,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:41,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:42,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:43,075 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:43,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:44,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:45,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:46,240 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:47,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:48,076 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:48,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:49,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:50,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:51,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:52,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:53,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:53,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:54,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:55,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:56,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:57,241 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:58,077 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:49:58,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:49:59,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:00,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:01,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:02,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:03,077 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:50:03,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:03,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:04,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:05,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:06,242 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:07,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:08,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:08,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:09,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:10,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:11,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:12,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:13,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:13,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:14,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:15,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:16,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:17,243 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:18,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:18,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:19,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:20,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:21,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:22,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:23,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:23,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:24,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:25,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:26,244 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:27,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:28,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:28,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:29,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:30,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:31,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:32,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:33,079 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:50:33,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:34,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:34,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:35,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:36,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:37,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:38,245 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:39,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:39,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:40,014 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:50:40,015 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:50:40,016 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:50:40,026 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:50:40,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:40,724 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:50:40,724 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:50:41,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:42,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:43,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:44,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:45,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:45,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:46,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:47,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:48,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:49,246 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:50,028 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:50,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:51,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:52,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:53,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:54,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:55,029 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:50:55,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:56,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:57,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:58,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:50:59,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:00,030 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:00,247 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:01,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:02,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:03,078 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:51:03,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:04,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:05,079 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:05,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:06,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:07,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:08,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:09,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:10,080 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:10,248 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:11,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:12,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:13,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:14,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:15,081 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:15,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:16,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:17,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:18,249 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:19,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:20,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:20,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:21,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:22,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:23,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:24,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:25,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:25,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:26,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:27,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:28,250 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:29,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:30,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:30,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:31,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:32,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:33,082 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:51:33,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:34,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:35,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:36,083 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:36,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:37,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:38,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:39,251 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:40,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:41,084 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:41,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:42,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:43,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:44,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:45,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:46,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:46,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:47,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:48,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:49,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:50,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:51,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:51,252 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:52,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:53,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:54,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:54,850 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:51:54,851 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:51:54,852 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:51:54,870 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:51:55,201 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:51:55,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:56,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:56,870 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:51:57,236 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:51:57,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:58,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:51:59,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:00,253 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:01,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:01,871 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:02,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:03,084 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:52:03,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:04,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:05,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:06,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:07,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:07,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:08,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:09,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:10,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:11,254 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:12,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:12,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:13,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:14,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:15,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:16,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:17,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:17,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:18,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:19,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:20,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:21,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:22,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:22,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:23,255 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:24,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:25,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:26,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:27,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:27,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:28,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:29,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:30,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:31,256 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:32,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:32,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:33,083 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:52:33,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:34,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:35,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:36,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:37,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:38,085 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:38,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:39,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:40,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:41,257 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:42,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:43,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:43,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:44,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:45,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:46,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:47,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:48,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:48,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:49,258 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:50,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:51,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:52,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:53,088 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:53,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:54,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:55,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:56,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:57,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:58,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:52:58,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:52:59,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:00,259 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:01,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:02,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:03,085 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:53:03,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:04,086 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:04,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:05,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:06,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:07,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:08,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:09,087 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:09,260 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:09,566 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:53:09,567 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:53:09,567 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:53:09,578 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:53:09,667 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:53:10,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:11,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:11,710 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:53:12,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:13,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:14,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:14,593 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:15,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:16,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:17,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:18,261 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:19,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:19,593 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:20,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:21,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:22,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:23,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:24,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:24,594 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:25,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:26,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:27,262 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:28,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:29,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:29,595 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:30,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:31,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:32,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:33,117 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:53:33,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:34,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:35,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:35,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:36,263 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:37,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:38,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:39,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:40,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:40,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:41,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:42,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:43,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:44,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:45,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:45,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:46,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:47,264 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:48,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:49,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:50,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:50,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:51,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:52,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:53,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:54,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:55,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:53:55,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:56,265 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:57,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:58,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:53:59,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:00,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:00,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:01,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:02,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:03,088 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:54:03,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:04,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:05,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:06,089 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:06,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:07,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:08,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:09,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:10,266 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:11,090 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:11,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:12,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:13,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:14,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:15,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:16,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:16,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:17,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:18,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:19,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:20,267 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:21,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:21,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:22,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:23,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:24,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:24,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:54:24,315 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:54:24,315 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:54:24,326 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:54:25,141 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:54:25,141 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:54:25,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:26,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:26,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:27,179 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:54:27,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:28,268 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:29,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:30,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:31,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:31,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:32,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:33,090 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:54:33,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:34,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:35,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:36,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:37,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:37,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:38,269 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:39,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:40,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:41,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:42,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:42,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:43,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:44,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:45,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:46,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:47,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:47,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:48,270 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:49,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:50,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:51,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:52,093 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:52,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:53,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:54,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:55,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:56,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:57,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:54:57,271 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:58,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:54:59,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:00,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:01,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:02,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:02,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:03,093 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:55:03,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:04,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:05,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:06,272 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:07,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:08,094 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:08,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:09,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:10,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:11,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:12,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:13,095 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:13,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:14,273 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:15,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:16,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:17,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:18,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:18,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:19,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:20,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:21,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:22,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:23,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:23,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:24,274 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:25,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:26,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:27,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:28,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:28,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:29,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:30,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:31,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:32,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:33,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:33,132 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:55:33,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:34,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:35,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:36,275 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:37,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:38,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:38,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:39,022 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:55:39,023 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:55:39,023 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:55:39,035 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:55:39,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:39,642 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:55:40,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:41,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:41,689 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:55:42,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:43,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:44,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:44,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:45,276 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:46,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:47,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:48,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:49,036 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:49,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:50,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:51,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:52,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:53,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:54,037 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:54,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:55,277 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:56,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:57,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:58,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:55:59,041 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:55:59,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:00,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:01,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:02,278 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:03,094 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:56:03,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:04,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:04,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:05,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:06,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:07,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:08,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:09,096 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:09,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:10,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:11,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:12,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:13,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:14,097 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:14,279 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:15,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:16,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:17,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:18,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:19,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:19,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:20,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:21,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:22,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:23,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:24,098 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:24,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:25,280 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:26,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:27,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:28,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:29,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:29,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:30,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:31,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:32,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:33,097 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:56:33,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:34,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:35,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:35,281 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:36,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:37,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:38,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:39,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:40,099 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:40,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:41,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:42,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:43,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:44,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:45,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:45,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:46,282 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:47,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:48,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:49,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:50,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:50,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:51,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:52,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:53,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:53,686 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:56:53,687 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:56:53,687 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:56:53,699 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:56:54,175 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:56:54,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:55,191 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:56:55,283 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:55,699 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:56:56,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:57,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:58,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:56:59,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:00,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:00,700 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:01,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:02,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:03,124 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:57:03,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:04,284 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:05,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:06,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:06,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:07,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:08,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:09,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:10,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:11,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:11,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:12,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:13,285 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:14,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:15,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:16,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:16,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:17,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:18,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:19,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:20,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:21,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:21,286 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:22,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:23,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:24,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:25,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:26,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:26,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:27,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:28,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:29,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:30,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:31,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:31,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:32,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:33,099 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:57:33,287 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:34,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:35,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:36,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:37,100 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:37,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:38,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:39,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:40,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:41,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:42,101 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:42,288 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:43,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:44,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:45,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:46,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:47,102 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:47,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:48,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:49,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:50,289 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:51,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:52,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:52,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:53,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:54,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:55,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:56,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:57,103 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:57:57,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:58,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:57:59,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:00,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:01,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:02,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:02,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:03,102 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:58:03,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:04,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:05,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:06,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:07,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:08,104 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:08,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:08,450 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:58:08,451 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:58:08,451 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:58:08,469 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:58:08,628 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:58:09,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:09,650 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:58:10,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:11,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:12,291 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:13,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:13,470 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:14,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:15,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:16,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:17,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:18,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:18,471 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:19,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:20,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:21,292 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:22,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:23,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:23,471 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:24,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:25,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:26,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:27,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:28,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:28,472 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:29,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:30,293 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:31,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:32,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:33,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:33,349 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:58:34,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:34,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:35,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:36,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:37,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:38,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:39,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:39,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:40,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:41,294 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:42,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:43,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:44,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:44,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:45,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:46,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:47,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:48,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:49,295 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:49,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:50,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:51,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:52,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:53,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:54,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:54,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:58:55,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:56,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:57,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:58,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:59,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:58:59,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:00,296 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:01,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:02,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:03,104 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:59:03,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:04,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:05,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:05,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:06,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:07,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:08,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:09,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:10,105 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:10,297 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:11,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:12,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:13,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:14,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:15,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:15,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:16,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:17,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:18,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:19,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:20,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:20,298 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:21,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:22,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:23,042 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 04:59:23,043 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 04:59:23,043 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 04:59:23,070 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:59:23,070 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 04:59:23,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:24,084 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 04:59:24,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:25,113 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 04:59:25,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:26,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:26,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:27,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:28,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:29,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:30,299 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:31,082 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:31,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:32,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:33,105 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 04:59:33,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:34,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:35,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:36,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:36,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:37,300 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:38,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:39,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:40,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:41,107 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:41,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:42,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:43,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:44,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:45,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:46,108 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:46,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:47,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:48,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:49,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:50,301 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:51,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:51,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:52,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:53,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:54,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:55,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:56,109 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 04:59:56,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:57,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:58,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 04:59:59,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:00,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:01,110 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:01,302 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:02,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:03,109 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:00:03,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:04,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:05,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:06,111 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:06,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:07,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:08,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:09,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:10,303 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:11,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:11,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:12,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:13,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:14,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:15,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:16,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:16,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:17,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:18,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:19,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:20,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:21,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:21,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:22,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:23,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:24,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:25,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:26,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:26,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:27,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:28,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:29,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:30,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:31,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:31,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:32,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:33,114 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:00:33,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:34,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:35,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:36,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:36,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:37,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:37,730 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:00:37,731 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:00:37,731 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:00:37,747 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:00:38,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:38,578 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:00:39,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:39,615 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:00:40,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:41,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:41,748 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:42,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:43,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:44,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:45,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:46,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:46,748 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:47,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:48,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:49,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:50,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:51,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:51,749 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:52,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:53,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:54,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:55,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:56,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:56,749 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:00:57,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:58,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:00:59,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:00,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:01,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:01,750 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:02,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:03,111 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:01:03,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:04,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:05,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:06,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:07,112 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:07,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:08,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:09,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:10,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:11,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:12,113 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:12,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:13,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:14,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:15,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:16,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:17,114 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:17,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:18,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:19,311 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:20,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:21,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:22,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:22,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:23,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:24,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:25,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:26,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:27,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:27,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:28,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:29,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:30,312 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:31,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:32,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:32,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:33,114 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:01:33,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:34,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:35,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:36,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:37,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:38,115 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:38,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:39,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:40,313 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:41,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:42,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:43,116 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:43,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:44,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:45,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:46,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:47,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:48,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:48,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:49,314 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:50,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:51,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:52,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:52,434 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:01:52,435 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:01:52,435 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:01:52,447 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:01:52,887 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:01:53,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:53,447 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:53,910 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:01:54,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:55,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:56,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:57,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:58,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:01:58,448 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:01:59,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:00,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:01,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:02,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:03,117 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:02:03,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:04,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:04,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:05,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:06,316 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:07,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:08,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:09,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:09,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:10,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:11,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:12,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:13,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:14,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:14,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:15,317 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:16,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:17,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:18,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:19,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:19,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:20,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:21,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:22,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:23,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:24,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:24,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:25,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:26,318 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:27,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:28,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:29,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:29,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:30,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:31,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:32,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:33,116 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:02:33,319 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:34,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:35,117 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:35,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:36,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:37,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:38,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:39,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:40,118 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:40,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:41,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:42,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:43,320 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:44,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:45,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:45,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:46,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:47,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:48,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:49,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:50,119 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:50,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:51,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:52,321 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:53,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:54,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:55,120 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:02:55,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:56,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:57,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:58,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:02:59,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:00,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:00,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:01,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:02,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:03,119 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:03:03,322 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:04,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:05,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:06,121 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:06,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:07,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:03:07,163 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:03:07,163 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:03:07,176 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:03:07,291 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:03:07,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:08,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:09,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:09,323 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:03:10,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:11,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:11,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:12,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:13,323 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:14,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:15,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:16,177 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:16,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:17,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:18,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:19,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:20,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:21,178 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:21,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:22,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:23,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:24,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:25,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:26,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:26,324 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:27,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:28,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:29,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:30,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:31,179 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:31,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:32,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:33,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:34,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:35,325 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:36,180 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:36,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:37,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:38,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:38,601 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:03:39,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:40,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:41,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:41,602 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:42,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:43,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:44,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:45,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:46,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:46,603 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:47,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:48,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:49,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:50,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:51,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:51,604 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:52,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:53,327 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:54,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:55,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:56,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:56,604 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:03:57,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:58,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:03:59,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:00,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:01,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:01,605 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:02,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:03,121 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:04:03,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:04,328 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:05,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:06,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:07,122 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:07,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:08,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:09,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:10,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:11,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:12,123 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:12,329 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:13,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:14,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:15,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:16,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:17,124 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:17,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:18,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:19,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:20,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:21,330 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:21,898 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:04:21,900 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:04:21,900 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:04:21,910 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:04:22,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:22,772 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:04:22,911 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:23,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:23,787 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:04:24,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:25,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:26,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:27,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:27,912 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:28,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:29,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:30,331 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:31,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:32,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:32,913 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:33,123 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:04:33,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:34,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:35,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:36,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:37,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:38,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:38,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:39,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:40,332 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:41,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:42,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:43,125 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:43,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:44,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:45,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:46,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:47,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:48,126 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:48,333 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:49,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:50,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:51,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:52,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:53,127 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:53,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:54,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:55,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:56,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:57,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:58,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:04:58,334 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:04:59,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:00,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:01,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:02,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:03,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:03,131 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:05:03,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:04,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:05,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:06,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:07,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:08,133 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:08,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:09,335 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:10,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:11,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:12,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:13,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:13,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:14,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:15,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:16,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:17,336 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:18,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:18,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:19,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:20,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:21,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:22,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:23,135 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:23,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:24,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:25,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:26,337 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:27,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:28,136 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:28,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:29,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:30,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:31,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:32,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:33,126 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:05:33,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:34,128 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:34,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:35,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:36,338 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:36,626 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:05:36,627 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:05:36,627 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:05:36,638 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:05:37,145 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:05:37,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:38,171 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:05:38,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:39,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:39,638 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:40,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:41,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:42,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:43,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:44,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:44,639 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:45,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:46,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:47,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:48,339 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:49,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:49,639 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:50,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:51,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:52,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:53,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:54,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:54,640 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:05:55,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:56,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:57,340 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:58,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:59,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:05:59,640 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:00,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:01,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:02,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:03,128 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:06:03,341 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:04,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:05,129 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:05,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:06,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:07,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:08,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:09,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:10,130 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:10,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:11,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:12,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:13,342 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:14,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:15,131 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:15,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:16,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:17,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:18,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:19,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:20,131 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:20,343 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:21,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:22,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:23,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:24,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:25,132 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:25,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:26,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:27,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:28,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:29,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:30,133 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:30,344 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:31,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:32,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:33,132 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:06:33,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:34,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:35,133 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:35,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:36,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:37,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:38,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:39,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:40,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:40,345 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:41,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:42,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:43,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:44,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:45,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:45,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:46,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:47,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:48,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:49,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:50,135 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:50,346 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:51,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:06:51,311 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:06:51,311 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:06:51,341 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:06:51,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:51,536 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:06:52,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:53,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:53,575 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:06:54,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:55,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:55,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:06:56,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:57,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:58,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:06:59,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:00,347 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:00,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:01,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:02,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:03,132 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:07:03,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:04,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:05,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:06,133 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:06,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:07,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:08,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:09,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:10,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:11,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:11,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:12,348 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:13,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:14,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:15,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:16,134 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:16,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:17,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:18,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:19,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:20,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:21,135 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:21,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:22,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:23,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:24,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:25,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:26,136 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:26,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:27,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:28,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:29,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:30,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:31,136 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:31,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:32,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:33,134 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:07:33,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:34,350 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:35,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:36,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:37,135 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:37,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:38,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:39,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:40,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:41,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:42,136 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:42,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:43,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:44,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:45,351 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:46,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:47,136 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:47,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:48,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:49,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:50,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:51,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:52,137 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:52,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:53,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:54,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:55,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:56,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:57,137 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:07:57,352 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:58,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:07:59,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:00,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:01,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:02,138 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:02,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:03,135 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:08:03,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:04,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:05,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:05,986 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:08:05,987 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:08:05,988 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:08:05,999 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:08:06,353 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:06,937 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:08:07,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:07,955 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:08:08,000 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:08,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:09,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:10,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:11,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:12,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:13,001 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:13,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:14,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:15,354 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:16,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:17,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:18,001 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:18,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:19,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:20,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:21,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:22,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:23,002 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:23,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:24,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:25,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:26,355 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:27,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:28,002 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:28,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:29,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:30,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:31,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:32,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:33,003 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:33,190 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:08:33,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:34,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:35,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:36,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:37,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:38,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:38,356 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:39,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:40,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:41,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:42,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:43,192 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:43,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:44,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:45,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:46,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:47,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:48,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:48,357 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:49,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:50,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:51,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:52,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:53,193 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:53,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:54,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:55,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:56,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:57,358 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:58,194 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:08:58,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:08:59,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:00,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:01,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:02,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:03,139 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:09:03,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:04,140 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:04,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:05,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:06,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:07,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:08,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:09,141 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:09,359 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:10,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:11,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:12,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:13,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:14,141 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:14,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:15,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:16,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:17,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:18,360 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:19,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:19,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:20,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:20,738 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:09:20,739 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:09:20,739 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:09:20,753 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:09:21,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:21,408 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:09:21,408 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:09:22,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:23,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:24,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:24,754 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:25,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:26,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:27,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:28,361 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:29,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:29,754 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:30,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:31,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:32,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:33,140 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:09:33,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:34,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:35,142 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:35,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:36,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:37,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:38,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:39,362 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:40,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:40,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:41,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:42,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:43,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:44,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:45,143 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:45,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:46,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:47,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:48,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:49,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:50,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:50,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:51,363 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:52,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:53,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:54,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:55,144 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:09:55,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:56,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:57,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:58,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:09:59,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:00,145 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:00,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:01,364 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:02,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:03,147 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:10:03,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:04,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:05,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:05,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:06,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:07,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:08,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:09,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:10,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:10,365 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:11,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:12,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:13,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:14,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:15,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:15,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:16,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:17,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:18,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:19,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:20,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:20,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:21,366 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:22,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:23,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:24,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:25,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:25,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:26,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:27,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:28,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:29,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:30,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:30,367 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:31,368 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:32,368 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:33,144 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:10:33,368 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:34,368 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:35,349 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:35,390 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:10:35,391 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:35,391 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:10:35,392 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:10:35,401 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:10:35,711 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:10:36,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:37,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:37,767 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:10:38,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:39,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:40,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:40,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:41,369 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:42,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:43,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:44,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:45,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:45,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:46,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:47,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:48,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:49,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:50,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:50,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:51,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:52,370 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:53,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:54,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:55,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:55,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:10:56,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:57,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:58,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:10:59,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:00,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:00,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:01,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:02,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:03,145 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:11:03,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:04,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:05,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:06,146 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:06,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:07,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:08,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:09,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:10,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:11,147 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:11,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:12,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:13,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:14,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:15,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:16,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:16,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:17,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:18,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:19,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:20,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:21,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:21,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:22,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:23,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:24,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:25,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:26,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:26,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:27,373 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:28,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:29,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:30,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:31,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:31,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:32,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:33,147 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:11:33,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:34,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:35,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:36,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:37,148 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:37,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:38,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:39,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:40,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:41,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:42,149 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:42,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:43,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:44,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:45,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:46,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:47,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:47,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:48,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:49,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:49,802 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:11:49,803 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:11:49,804 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:11:49,815 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:11:50,064 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:11:50,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:51,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:52,101 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:11:52,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:52,815 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:53,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:54,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:55,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:56,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:57,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:57,816 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:11:58,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:11:59,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:00,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:01,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:02,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:02,817 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:03,148 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:12:03,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:04,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:05,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:06,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:07,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:08,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:08,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:09,377 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:10,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:11,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:12,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:13,150 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:13,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:14,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:15,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:16,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:17,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:18,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:18,378 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:19,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:20,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:21,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:22,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:23,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:23,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:24,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:25,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:26,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:27,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:28,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:28,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:29,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:30,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:31,379 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:32,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:33,150 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:12:33,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:34,151 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:34,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:35,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:36,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:37,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:38,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:39,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:39,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:40,380 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:41,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:42,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:43,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:44,152 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:44,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:45,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:46,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:47,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:48,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:49,153 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:49,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:50,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:51,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:52,381 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:53,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:54,153 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:54,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:55,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:56,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:57,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:58,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:12:59,154 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:12:59,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:00,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:01,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:02,382 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:03,152 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:13:03,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:04,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:04,533 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:04,574 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:13:04,575 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:13:04,576 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:13:04,587 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:13:05,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:05,503 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:13:06,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:06,517 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:13:07,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:08,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:09,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:09,637 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:10,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:11,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:12,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:13,383 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:14,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:14,637 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:15,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:16,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:17,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:18,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:19,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:19,638 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:20,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:21,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:22,384 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:23,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:24,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:24,639 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:25,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:26,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:27,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:28,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:29,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:29,639 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:30,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:31,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:32,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:33,153 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:13:33,385 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:34,398 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:35,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:35,398 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:36,398 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:37,398 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:38,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:39,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:40,155 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:40,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:41,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:42,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:43,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:44,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:45,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:45,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:46,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:47,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:48,399 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:49,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:50,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:50,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:51,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:52,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:53,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:54,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:55,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:13:55,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:56,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:57,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:58,400 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:13:59,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:00,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:00,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:01,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:02,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:03,155 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:14:03,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:04,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:05,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:06,156 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:06,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:07,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:08,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:09,401 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:10,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:11,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:11,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:12,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:13,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:14,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:15,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:16,157 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:16,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:17,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:18,402 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:19,290 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:14:19,291 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:14:19,291 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:14:19,303 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:14:19,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:19,840 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:14:20,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:21,304 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:21,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:21,876 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:14:22,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:23,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:24,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:25,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:26,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:26,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:27,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:28,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:29,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:30,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:31,305 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:31,403 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:32,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:33,157 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:14:33,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:34,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:35,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:36,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:37,158 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:37,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:38,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:39,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:40,404 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:41,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:42,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:42,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:43,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:44,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:45,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:46,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:47,159 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:47,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:48,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:49,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:50,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:51,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:52,160 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:52,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:53,405 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:54,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:55,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:56,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:57,161 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:14:57,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:58,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:14:59,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:00,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:01,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:02,162 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:02,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:03,163 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:15:03,406 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:04,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:05,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:06,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:07,164 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:07,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:08,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:09,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:10,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:11,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:12,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:12,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:13,407 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:14,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:15,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:16,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:17,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:17,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:18,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:19,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:20,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:21,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:22,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:22,408 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:23,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:24,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:25,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:26,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:27,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:27,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:28,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:29,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:30,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:31,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:32,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:32,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:33,162 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:15:33,409 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:34,106 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:15:34,107 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:15:34,107 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:15:34,119 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:15:34,169 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:15:34,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:35,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:36,207 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:15:36,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:37,306 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:37,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:38,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:39,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:40,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:41,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:42,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:42,410 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:43,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:44,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:45,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:46,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:47,307 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:47,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:48,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:49,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:50,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:51,411 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:52,308 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:52,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:53,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:54,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:55,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:56,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:57,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:15:57,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:58,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:15:59,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:00,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:01,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:02,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:02,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:03,163 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:16:03,412 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:04,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:05,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:06,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:07,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:08,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:08,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:09,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:10,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:11,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:12,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:13,165 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:13,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:14,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:15,413 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:16,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:17,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:18,166 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:18,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:19,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:20,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:21,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:22,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:23,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:23,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:24,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:25,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:26,414 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:27,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:28,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:28,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:29,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:30,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:31,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:32,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:33,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:33,169 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:16:33,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:34,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:35,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:36,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:37,415 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:38,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:38,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:39,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:40,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:41,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:42,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:43,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:43,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:44,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:45,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:46,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:47,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:48,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:48,416 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:49,078 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:16:49,079 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:16:49,079 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:16:49,090 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:16:49,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:49,558 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:16:50,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:50,578 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:16:51,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:52,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:53,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:54,091 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:54,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:55,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:56,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:57,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:58,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:16:59,092 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:16:59,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:00,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:01,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:02,417 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:03,166 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:17:03,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:04,167 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:04,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:05,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:06,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:07,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:08,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:09,168 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:09,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:10,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:11,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:12,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:13,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:14,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:14,418 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:15,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:16,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:17,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:18,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:19,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:19,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:20,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:21,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:22,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:23,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:24,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:24,419 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:25,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:26,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:27,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:28,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:29,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:29,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:30,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:31,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:32,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:33,168 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:17:33,420 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:34,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:35,169 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:35,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:36,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:37,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:38,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:39,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:40,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:40,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:41,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:42,421 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:43,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:44,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:45,170 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:45,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:46,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:47,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:48,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:49,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:50,171 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:50,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:51,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:52,422 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:53,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:54,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:55,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:17:55,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:56,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:57,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:58,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:17:59,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:00,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:00,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:01,423 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:02,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:03,169 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:18:03,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:03,685 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:18:03,686 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:18:03,686 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:18:03,696 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:18:03,937 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:18:04,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:05,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:05,697 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:05,966 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:18:06,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:07,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:08,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:09,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:10,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:10,697 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:11,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:12,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:13,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:14,424 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:15,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:15,698 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:16,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:17,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:18,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:19,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:20,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:20,699 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:21,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:22,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:23,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:24,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:25,425 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:25,699 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:26,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:27,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:28,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:29,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:30,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:30,700 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:31,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:32,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:33,171 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:18:33,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:34,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:35,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:36,172 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:36,426 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:37,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:38,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:39,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:40,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:41,173 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:41,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:42,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:43,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:44,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:45,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:46,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:46,427 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:47,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:48,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:49,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:50,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:51,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:51,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:52,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:53,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:54,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:55,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:56,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:18:56,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:57,428 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:58,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:18:59,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:00,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:01,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:19:01,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:02,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:03,172 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:19:03,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:04,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:05,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:06,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:07,174 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:19:07,429 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:08,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:09,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:10,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:11,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:12,175 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:19:12,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:13,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:14,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:15,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:16,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:17,176 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:19:17,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:18,430 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:18,686 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: partial_history +2024-07-21 05:19:18,687 DEBUG SenderThread:2236926 [sender.py:send():379] send: history +2024-07-21 05:19:18,687 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: summary_record +2024-07-21 05:19:18,699 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:19:18,842 DEBUG SenderThread:2236926 [sender.py:send():379] send: exit +2024-07-21 05:19:18,842 INFO SenderThread:2236926 [sender.py:send_exit():586] handling exit code: 0 +2024-07-21 05:19:18,842 INFO SenderThread:2236926 [sender.py:send_exit():588] handling runtime: 5986 +2024-07-21 05:19:18,852 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:19:18,853 INFO SenderThread:2236926 [sender.py:send_exit():594] send defer +2024-07-21 05:19:18,853 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:18,853 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 0 +2024-07-21 05:19:18,854 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:18,854 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 0 +2024-07-21 05:19:18,854 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 1 +2024-07-21 05:19:18,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:18,854 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 1 +2024-07-21 05:19:18,854 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:18,854 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 1 +2024-07-21 05:19:18,854 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 2 +2024-07-21 05:19:18,854 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:18,854 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 2 +2024-07-21 05:19:18,854 INFO HandlerThread:2236926 [system_monitor.py:finish():203] Stopping system monitor +2024-07-21 05:19:18,855 DEBUG SystemMonitor:2236926 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-07-21 05:19:18,855 INFO HandlerThread:2236926 [interfaces.py:finish():200] Joined cpu monitor +2024-07-21 05:19:18,855 DEBUG SystemMonitor:2236926 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-07-21 05:19:18,855 INFO HandlerThread:2236926 [interfaces.py:finish():200] Joined disk monitor +2024-07-21 05:19:19,364 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:19:20,309 INFO HandlerThread:2236926 [interfaces.py:finish():200] Joined gpu monitor +2024-07-21 05:19:20,309 INFO HandlerThread:2236926 [interfaces.py:finish():200] Joined memory monitor +2024-07-21 05:19:20,309 INFO HandlerThread:2236926 [interfaces.py:finish():200] Joined network monitor +2024-07-21 05:19:20,309 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:20,310 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,310 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 2 +2024-07-21 05:19:20,310 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 3 +2024-07-21 05:19:20,310 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:20,310 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 3 +2024-07-21 05:19:20,313 DEBUG SenderThread:2236926 [sender.py:send():379] send: stats +2024-07-21 05:19:20,314 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:20,315 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,315 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 3 +2024-07-21 05:19:20,315 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 4 +2024-07-21 05:19:20,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:20,315 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 4 +2024-07-21 05:19:20,315 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,315 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 4 +2024-07-21 05:19:20,315 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 5 +2024-07-21 05:19:20,315 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:20,315 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 5 +2024-07-21 05:19:20,315 DEBUG SenderThread:2236926 [sender.py:send():379] send: summary +2024-07-21 05:19:20,325 INFO SenderThread:2236926 [sender.py:_save_file():1454] saving file wandb-summary.json with policy end +2024-07-21 05:19:20,326 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,326 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 5 +2024-07-21 05:19:20,326 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 6 +2024-07-21 05:19:20,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:20,326 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 6 +2024-07-21 05:19:20,326 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,326 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 6 +2024-07-21 05:19:20,326 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 7 +2024-07-21 05:19:20,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: status_report +2024-07-21 05:19:20,326 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:20,326 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 7 +2024-07-21 05:19:20,327 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:20,327 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 7 +2024-07-21 05:19:20,381 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:19:20,381 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:19:20,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:21,395 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:19:21,789 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 8 +2024-07-21 05:19:21,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:21,790 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:21,790 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 8 +2024-07-21 05:19:21,790 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:21,790 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 8 +2024-07-21 05:19:21,791 INFO SenderThread:2236926 [job_builder.py:build():440] Attempting to build job artifact +2024-07-21 05:19:21,799 INFO SenderThread:2236926 [job_builder.py:_get_source_type():569] is repo sourced job +2024-07-21 05:19:21,843 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:21,854 INFO SenderThread:2236926 [job_builder.py:build():545] adding wandb-job metadata file +2024-07-21 05:19:21,884 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 9 +2024-07-21 05:19:21,884 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:21,884 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:21,884 DEBUG SenderThread:2236926 [sender.py:send():379] send: artifact +2024-07-21 05:19:21,884 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 9 +2024-07-21 05:19:22,418 INFO Thread-12 :2236926 [dir_watcher.py:_on_file_modified():288] file/dir modified: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:19:22,844 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:22,876 INFO wandb-upload_0:2236926 [upload_job.py:push():88] Uploaded file /admin/home-ckadirt/.local/share/wandb/artifacts/staging/tmpwh3ia28v +2024-07-21 05:19:22,951 INFO wandb-upload_2:2236926 [upload_job.py:push():88] Uploaded file /admin/home-ckadirt/.local/share/wandb/artifacts/staging/tmp6urhgela +2024-07-21 05:19:22,989 INFO wandb-upload_1:2236926 [upload_job.py:push():88] Uploaded file /tmp/tmpvb02mwdc/wandb-job.json +2024-07-21 05:19:23,564 INFO SenderThread:2236926 [sender.py:send_artifact():1530] sent artifact job-https___github.com_MedARC-AI_MindEyeV2.git_src_TrainBold5000.py - {'id': 'QXJ0aWZhY3Q6ODgzODQ2', 'state': 'PENDING', 'artifactSequence': {'id': 'QXJ0aWZhY3RDb2xsZWN0aW9uOjQ4ODky', 'latestArtifact': None}} +2024-07-21 05:19:23,564 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:23,564 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 9 +2024-07-21 05:19:23,564 INFO SenderThread:2236926 [dir_watcher.py:finish():358] shutting down directory watcher +2024-07-21 05:19:24,438 INFO SenderThread:2236926 [dir_watcher.py:finish():388] scan: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files +2024-07-21 05:19:24,442 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json wandb-summary.json +2024-07-21 05:19:24,442 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-metadata.json wandb-metadata.json +2024-07-21 05:19:24,442 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log output.log +2024-07-21 05:19:24,444 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml config.yaml +2024-07-21 05:19:24,445 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt requirements.txt +2024-07-21 05:19:24,447 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/diff.patch diff.patch +2024-07-21 05:19:24,451 INFO SenderThread:2236926 [dir_watcher.py:finish():402] scan save: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/code/src/TrainBold5000.py code/src/TrainBold5000.py +2024-07-21 05:19:24,451 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 10 +2024-07-21 05:19:24,451 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:24,451 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:24,452 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 10 +2024-07-21 05:19:24,452 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:24,452 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 10 +2024-07-21 05:19:24,452 INFO SenderThread:2236926 [file_pusher.py:finish():169] shutting down file pusher +2024-07-21 05:19:24,626 INFO wandb-upload_0:2236926 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/wandb-summary.json +2024-07-21 05:19:24,824 INFO wandb-upload_2:2236926 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/config.yaml +2024-07-21 05:19:24,834 INFO wandb-upload_1:2236926 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/output.log +2024-07-21 05:19:24,845 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:24,846 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:24,850 INFO wandb-upload_3:2236926 [upload_job.py:push():130] Uploaded file /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/files/requirements.txt +2024-07-21 05:19:25,050 INFO Thread-11 (_thread_body):2236926 [sender.py:transition_state():614] send defer: 11 +2024-07-21 05:19:25,051 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:25,051 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 11 +2024-07-21 05:19:25,051 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:25,051 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 11 +2024-07-21 05:19:25,051 INFO SenderThread:2236926 [file_pusher.py:join():175] waiting for file pusher +2024-07-21 05:19:25,052 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 12 +2024-07-21 05:19:25,052 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:25,052 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 12 +2024-07-21 05:19:25,052 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:25,052 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 12 +2024-07-21 05:19:25,052 INFO SenderThread:2236926 [file_stream.py:finish():601] file stream finish called +2024-07-21 05:19:25,370 INFO SenderThread:2236926 [file_stream.py:finish():605] file stream finish is done +2024-07-21 05:19:25,370 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 13 +2024-07-21 05:19:25,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:25,371 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 13 +2024-07-21 05:19:25,371 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:25,371 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 13 +2024-07-21 05:19:25,371 INFO SenderThread:2236926 [sender.py:transition_state():614] send defer: 14 +2024-07-21 05:19:25,371 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: defer +2024-07-21 05:19:25,371 DEBUG SenderThread:2236926 [sender.py:send():379] send: final +2024-07-21 05:19:25,371 INFO HandlerThread:2236926 [handler.py:handle_request_defer():184] handle defer: 14 +2024-07-21 05:19:25,371 DEBUG SenderThread:2236926 [sender.py:send():379] send: footer +2024-07-21 05:19:25,371 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: defer +2024-07-21 05:19:25,372 INFO SenderThread:2236926 [sender.py:send_request_defer():610] handle sender defer: 14 +2024-07-21 05:19:25,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:25,372 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: server_info +2024-07-21 05:19:25,372 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:25,373 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: server_info +2024-07-21 05:19:25,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: poll_exit +2024-07-21 05:19:25,374 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: get_summary +2024-07-21 05:19:25,375 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: sampled_history +2024-07-21 05:19:25,376 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: internal_messages +2024-07-21 05:19:25,444 DEBUG SenderThread:2236926 [sender.py:send_request():406] send_request: poll_exit +2024-07-21 05:19:25,444 INFO MainThread:2236926 [wandb_run.py:_footer_history_summary_info():4008] rendering history +2024-07-21 05:19:25,445 INFO MainThread:2236926 [wandb_run.py:_footer_history_summary_info():4040] rendering summary +2024-07-21 05:19:25,446 INFO MainThread:2236926 [wandb_run.py:_footer_sync_info():3967] logging synced files +2024-07-21 05:19:25,446 DEBUG HandlerThread:2236926 [handler.py:handle_request():158] handle_request: shutdown +2024-07-21 05:19:25,446 INFO HandlerThread:2236926 [handler.py:finish():882] shutting down handler +2024-07-21 05:19:26,374 INFO WriterThread:2236926 [datastore.py:close():296] close: /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/run-augmented_image_one.wandb +2024-07-21 05:19:26,444 INFO SenderThread:2236926 [sender.py:finish():1608] shutting down sender +2024-07-21 05:19:26,444 INFO SenderThread:2236926 [file_pusher.py:finish():169] shutting down file pusher +2024-07-21 05:19:26,445 INFO SenderThread:2236926 [file_pusher.py:join():175] waiting for file pusher diff --git a/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug.log b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..a410567025ec1b5ec3fbbcd7fddd7f2e472fc333 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug.log @@ -0,0 +1,29 @@ +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Configure stats pid to 2199630 +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False} +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': 'src/TrainBold5000.py', 'program_abspath': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainBold5000.py', 'program': '/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainBold5000.py'} +2024-07-21 03:39:32,060 INFO MainThread:2199630 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-07-21 03:39:32,061 INFO MainThread:2199630 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug.log +2024-07-21 03:39:32,062 INFO MainThread:2199630 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20240721_033931-augmented_image_one/logs/debug-internal.log +2024-07-21 03:39:32,062 INFO MainThread:2199630 [wandb_init.py:init():560] calling init triggers +2024-07-21 03:39:32,062 INFO MainThread:2199630 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'augmented_image_one', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 80, 'num_sessions': 14, 'num_params': 2154632456, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 5254, 'num_test': 370, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1} +2024-07-21 03:39:32,062 INFO MainThread:2199630 [wandb_init.py:init():610] starting backend +2024-07-21 03:39:32,062 INFO MainThread:2199630 [wandb_init.py:init():614] setting up manager +2024-07-21 03:39:32,072 INFO MainThread:2199630 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-07-21 03:39:32,075 INFO MainThread:2199630 [wandb_init.py:init():622] backend started and connected +2024-07-21 03:39:32,097 INFO MainThread:2199630 [wandb_init.py:init():711] updated telemetry +2024-07-21 03:39:32,137 INFO MainThread:2199630 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-07-21 03:39:32,666 INFO MainThread:2199630 [wandb_run.py:_on_init():2402] communicating current version +2024-07-21 03:39:32,721 INFO MainThread:2199630 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.17.5 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-07-21 03:39:32,721 INFO MainThread:2199630 [wandb_init.py:init():795] starting run threads in backend +2024-07-21 03:39:38,765 INFO MainThread:2199630 [wandb_run.py:_console_start():2380] atexit reg +2024-07-21 03:39:38,765 INFO MainThread:2199630 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-07-21 03:39:38,766 INFO MainThread:2199630 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-07-21 03:39:38,766 INFO MainThread:2199630 [wandb_run.py:_redirect():2325] Redirects installed. +2024-07-21 03:39:38,769 INFO MainThread:2199630 [wandb_init.py:init():838] run started, returning control to user process +2024-07-21 05:19:26,446 WARNING MsgRouterThr:2199630 [router.py:message_loop():77] message_loop has been closed diff --git a/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/logs/debug.log b/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..7f493f6592ec72896e03bf601fee265db4952b78 --- /dev/null +++ b/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/logs/debug.log @@ -0,0 +1,46 @@ +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Current SDK version is 0.17.1 +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Configure stats pid to 4011488 +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Loading settings from /admin/home-ckadirt/.config/wandb/settings +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Loading settings from /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/settings +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False} +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program': ''} +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_init.py:_log_setup():520] Logging user logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/logs/debug.log +2024-12-10 21:13:34,286 INFO MainThread:4011488 [wandb_init.py:_log_setup():521] Logging internal logs to /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/logs/debug-internal.log +2024-12-10 21:13:34,287 INFO MainThread:4011488 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks +2024-12-10 21:13:34,287 INFO MainThread:4011488 [wandb_init.py:init():560] calling init triggers +2024-12-10 21:13:34,287 INFO MainThread:4011488 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'model_name': 'testingbold5000', 'global_batch_size': 8, 'batch_size': 8, 'num_epochs': 150, 'num_sessions': 14, 'num_params': 2154632456, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 5254, 'num_test': 370, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1} +2024-12-10 21:13:34,287 INFO MainThread:4011488 [wandb_init.py:init():610] starting backend +2024-12-10 21:13:34,287 INFO MainThread:4011488 [wandb_init.py:init():614] setting up manager +2024-12-10 21:13:34,289 INFO MainThread:4011488 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-12-10 21:13:34,299 INFO MainThread:4011488 [wandb_init.py:init():622] backend started and connected +2024-12-10 21:13:34,306 INFO MainThread:4011488 [wandb_run.py:_label_probe_notebook():1334] probe notebook +2024-12-10 21:13:34,306 INFO MainThread:4011488 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get' +2024-12-10 21:13:34,306 INFO MainThread:4011488 [wandb_init.py:init():711] updated telemetry +2024-12-10 21:13:34,331 INFO MainThread:4011488 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-12-10 21:13:34,953 INFO MainThread:4011488 [wandb_init.py:init():787] run resumed +2024-12-10 21:13:34,972 INFO MainThread:4011488 [wandb_run.py:_on_init():2402] communicating current version +2024-12-10 21:13:35,037 INFO MainThread:4011488 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.19.0 is available! To upgrade, please run:\n $ pip install wandb --upgrade" + +2024-12-10 21:13:35,038 INFO MainThread:4011488 [wandb_init.py:init():795] starting run threads in backend +2024-12-10 21:13:35,955 INFO MainThread:4011488 [wandb_run.py:_console_start():2380] atexit reg +2024-12-10 21:13:35,955 INFO MainThread:4011488 [wandb_run.py:_redirect():2235] redirect: wrap_raw +2024-12-10 21:13:35,955 INFO MainThread:4011488 [wandb_run.py:_redirect():2300] Wrapping output streams. +2024-12-10 21:13:35,955 INFO MainThread:4011488 [wandb_run.py:_redirect():2325] Redirects installed. +2024-12-10 21:13:35,970 INFO MainThread:4011488 [wandb_init.py:init():838] run started, returning control to user process +2024-12-10 21:13:35,975 INFO MainThread:4011488 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-12-10 21:13:35,976 INFO MainThread:4011488 [wandb_init.py:_pause_backend():431] pausing backend +2024-12-10 21:13:36,087 INFO MainThread:4011488 [wandb_init.py:_resume_backend():436] resuming backend +2024-12-10 21:13:36,089 INFO MainThread:4011488 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-12-10 21:13:36,089 INFO MainThread:4011488 [wandb_init.py:_pause_backend():431] pausing backend +2024-12-10 21:13:36,184 INFO MainThread:4011488 [wandb_init.py:_resume_backend():436] resuming backend +2024-12-10 21:13:36,207 INFO MainThread:4011488 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-12-10 21:13:36,207 INFO MainThread:4011488 [wandb_init.py:_pause_backend():431] pausing backend +2024-12-10 21:13:36,299 INFO MainThread:4011488 [wandb_init.py:_resume_backend():436] resuming backend +2024-12-10 21:13:37,397 INFO MainThread:4011488 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-12-10 21:13:37,398 INFO MainThread:4011488 [wandb_init.py:_pause_backend():431] pausing backend +2024-12-10 21:13:37,521 INFO MainThread:4011488 [wandb_init.py:_resume_backend():436] resuming backend +2024-12-10 21:39:13,477 INFO MainThread:4011488 [jupyter.py:_save_ipynb():383] looking for notebook: ckadirt/MindEyeV2/src/TrainBold5000.ipynb +2024-12-10 21:39:13,478 INFO MainThread:4011488 [wandb_init.py:_pause_backend():431] pausing backend diff --git a/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/run-testingbold5000.wandb b/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/run-testingbold5000.wandb new file mode 100644 index 0000000000000000000000000000000000000000..5352e418e39c5f9216e696edb7ac48805dc1172c Binary files /dev/null and b/MindEyeV2/src/wandb/run-20241210_211334-testingbold5000/run-testingbold5000.wandb differ