Add files using upload-large-folder tool

.gitattributes

@@ -806,3 +806,23 @@ evalkit_eagle/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda124.
 evalkit_eagle/lib/python3.10/site-packages/regex/_regex.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 evalkit_eagle/lib/python3.10/site-packages/scikit_learn.libs/libgomp-a34b3233.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
 evalkit_eagle/lib/python3.10/site-packages/scipy/spatial/_distance_pybind.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libgomp.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libgcc_s.so.1 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libtsan.so.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libatomic.so.1 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libtsan.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libstdc++.so.6 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libtk8.6.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libtsan.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libgomp.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libquadmath.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libubsan.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libreadline.so.8.2 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libitm.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libncursesw.so.6.4 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libbz2.so.1.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libncurses.so.6.4 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libasan.so filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libitm.so.1 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libncursesw.so.6 filter=lfs diff=lfs merge=lfs -text
+infer_4_47_1/lib/libbz2.so.1.0.8 filter=lfs diff=lfs merge=lfs -text

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/diffusers/resolvers/multimodal.py

@@ -0,0 +1,882 @@
+import logging
+from typing import Any, Dict, List, Sequence
+
+import wandb
+from wandb.sdk.integration_utils.auto_logging import Response
+
+from .utils import (
+    chunkify,
+    decode_sdxl_t2i_latents,
+    get_updated_kwargs,
+    postprocess_np_arrays_for_video,
+    postprocess_pils_to_np,
+)
+
+logger = logging.getLogger(__name__)
+
+
+SUPPORTED_MULTIMODAL_PIPELINES = {
+    "BlipDiffusionPipeline": {
+        "table-schema": [
+            "Reference-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Source-Subject-Category",
+            "Target-Subject-Category",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "reference_image",
+            "prompt",
+            "neg_prompt",
+            "source_subject_category",
+            "target_subject_category",
+        ],
+        "kwarg-actions": [wandb.Image, None, None, None, None],
+    },
+    "BlipDiffusionControlNetPipeline": {
+        "table-schema": [
+            "Reference-Image",
+            "Control-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Source-Subject-Category",
+            "Target-Subject-Category",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "reference_image",
+            "condtioning_image",
+            "prompt",
+            "neg_prompt",
+            "source_subject_category",
+            "target_subject_category",
+        ],
+        "kwarg-actions": [wandb.Image, wandb.Image, None, None, None, None],
+    },
+    "StableDiffusionControlNetPipeline": {
+        "table-schema": [
+            "Control-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionControlNetImg2ImgPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Control-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "control_image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, wandb.Image, None, None],
+    },
+    "StableDiffusionControlNetInpaintPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Mask-Image",
+            "Control-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+            "mask_image",
+            "control_image",
+            "prompt",
+            "negative_prompt",
+        ],
+        "kwarg-actions": [wandb.Image, wandb.Image, wandb.Image, None, None],
+    },
+    "CycleDiffusionPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Source-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+            "prompt",
+            "source_prompt",
+        ],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionInstructPix2PixPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+            "prompt",
+            "negative_prompt",
+        ],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "PaintByExamplePipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Example-Image",
+            "Mask-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+            "example_image",
+            "mask_image",
+        ],
+        "kwarg-actions": [wandb.Image, wandb.Image, wandb.Image],
+    },
+    "RePaintPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Mask-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+            "mask_image",
+        ],
+        "kwarg-actions": [wandb.Image, wandb.Image],
+    },
+    "StableDiffusionPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "KandinskyCombinedPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "KandinskyV22CombinedPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "LatentConsistencyModelPipeline": {
+        "table-schema": ["Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt"],
+        "kwarg-actions": [None],
+    },
+    "LDMTextToImagePipeline": {
+        "table-schema": ["Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt"],
+        "kwarg-actions": [None],
+    },
+    "StableDiffusionPanoramaPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "PixArtAlphaPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "StableDiffusionSAGPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "SemanticStableDiffusionPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "WuerstchenCombinedPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "IFPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "AltDiffusionPipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "StableDiffusionAttendAndExcitePipeline": {
+        "table-schema": ["Prompt", "Negative-Prompt", "Generated-Image"],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "KandinskyImg2ImgCombinedPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "KandinskyInpaintCombinedPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "KandinskyV22Img2ImgCombinedPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "KandinskyV22InpaintCombinedPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "AnimateDiffPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Number-of-Frames",
+            "Generated-Video",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "num_frames"],
+        "kwarg-actions": [None, None, None],
+        "output-type": "video",
+    },
+    "StableVideoDiffusionPipeline": {
+        "table-schema": [
+            "Input-Image",
+            "Frames-Per-Second",
+            "Generated-Video",
+        ],
+        "kwarg-logging": ["image", "fps"],
+        "kwarg-actions": [wandb.Image, None],
+        "output-type": "video",
+    },
+    "AudioLDMPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Audio-Length-in-Seconds",
+            "Generated-Audio",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "audio_length_in_s"],
+        "kwarg-actions": [None, None, None],
+        "output-type": "audio",
+    },
+    "AudioLDM2Pipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Audio-Length-in-Seconds",
+            "Generated-Audio",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "audio_length_in_s"],
+        "kwarg-actions": [None, None, None],
+        "output-type": "audio",
+    },
+    "MusicLDMPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Audio-Length-in-Seconds",
+            "Generated-Audio",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "audio_length_in_s"],
+        "kwarg-actions": [None, None, None],
+        "output-type": "audio",
+    },
+    "StableDiffusionPix2PixZeroPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "PNDMPipeline": {
+        "table-schema": [
+            "Batch-Size",
+            "Number-of-Inference-Steps",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["batch_size", "num_inference_steps"],
+        "kwarg-actions": [None, None],
+    },
+    "ShapEPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Generated-Video",
+        ],
+        "kwarg-logging": ["prompt"],
+        "kwarg-actions": [None],
+        "output-type": "video",
+    },
+    "StableDiffusionImg2ImgPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionInpaintPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Mask-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "mask_image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, wandb.Image, None, None],
+    },
+    "StableDiffusionDepth2ImgPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionImageVariationPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "image",
+        ],
+        "kwarg-actions": [wandb.Image],
+    },
+    "StableDiffusionPipelineSafe": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "StableDiffusionUpscalePipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Upscaled-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionAdapterPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "StableDiffusionGLIGENPipeline": {
+        "table-schema": [
+            "Prompt",
+            "GLIGEN-Phrases",
+            "GLIGEN-Boxes",
+            "GLIGEN-Inpaint-Image",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "gligen_phrases",
+            "gligen_boxes",
+            "gligen_inpaint_image",
+            "negative_prompt",
+        ],
+        "kwarg-actions": [None, None, None, wandb.Image, None],
+    },
+    "VersatileDiffusionTextToImagePipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt"],
+        "kwarg-actions": [None, None],
+    },
+    "VersatileDiffusionImageVariationPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None],
+    },
+    "VersatileDiffusionDualGuidedPipeline": {
+        "table-schema": [
+            "Source-Image",
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["image", "prompt", "negative_prompt"],
+        "kwarg-actions": [wandb.Image, None, None],
+    },
+    "LDMPipeline": {
+        "table-schema": [
+            "Batch-Size",
+            "Number-of-Inference-Steps",
+            "Generated-Image",
+        ],
+        "kwarg-logging": ["batch_size", "num_inference_steps"],
+        "kwarg-actions": [None, None],
+    },
+    "TextToVideoSDPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Number-of-Frames",
+            "Generated-Video",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "num_frames"],
+        "output-type": "video",
+    },
+    "TextToVideoZeroPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Number-of-Frames",
+            "Generated-Video",
+        ],
+        "kwarg-logging": ["prompt", "negative_prompt", "video_length"],
+    },
+    "AmusedPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Guidance Scale",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "guidance_scale",
+        ],
+        "kwarg-actions": [None, None],
+    },
+    "StableDiffusionXLControlNetPipeline": {
+        "table-schema": [
+            "Prompt-1",
+            "Prompt-2",
+            "Control-Image",
+            "Negative-Prompt-1",
+            "Negative-Prompt-2",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "prompt_2",
+            "image",
+            "negative_prompt",
+            "negative_prompt_2",
+        ],
+        "kwarg-actions": [None, None, wandb.Image, None, None],
+    },
+    "StableDiffusionXLControlNetImg2ImgPipeline": {
+        "table-schema": [
+            "Prompt-1",
+            "Prompt-2",
+            "Input-Image",
+            "Control-Image",
+            "Negative-Prompt-1",
+            "Negative-Prompt-2",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "prompt_2",
+            "image",
+            "control_image",
+            "negative_prompt",
+            "negative_prompt_2",
+        ],
+        "kwarg-actions": [None, None, wandb.Image, wandb.Image, None, None],
+    },
+    "Kandinsky3Pipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "negative_prompt",
+        ],
+        "kwarg-actions": [None, None],
+    },
+    "Kandinsky3Img2ImgPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Input-Image",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "negative_prompt",
+            "image",
+        ],
+        "kwarg-actions": [None, None, wandb.Image],
+    },
+    "StableDiffusionXLPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Prompt-2",
+            "Negative-Prompt-2",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "negative_prompt",
+            "prompt_2",
+            "negative_prompt_2",
+        ],
+        "kwarg-actions": [None, None, None, None],
+    },
+    "StableDiffusionXLImg2ImgPipeline": {
+        "table-schema": [
+            "Prompt",
+            "Negative-Prompt",
+            "Prompt-2",
+            "Negative-Prompt-2",
+            "Input-Image",
+            "Generated-Image",
+        ],
+        "kwarg-logging": [
+            "prompt",
+            "negative_prompt",
+            "prompt_2",
+            "negative_prompt_2",
+            "image",
+        ],
+        "kwarg-actions": [None, None, None, None, wandb.Image],
+    },
+}
+
+
+class DiffusersMultiModalPipelineResolver:
+    """Resolver for  request and responses from [HuggingFace Diffusers](https://huggingface.co/docs/diffusers/index) multi-modal Diffusion Pipelines, providing necessary data transformations, formatting, and logging.
+
+    This resolver is internally involved in the
+    `__call__` for `wandb.integration.diffusers.pipeline_resolver.DiffusersPipelineResolver`.
+    This is based on `wandb.sdk.integration_utils.auto_logging.RequestResponseResolver`.
+
+    Args:
+        pipeline_name: (str) The name of the Diffusion Pipeline.
+    """
+
+    def __init__(self, pipeline_name: str, pipeline_call_count: int) -> None:
+        self.pipeline_name = pipeline_name
+        self.pipeline_call_count = pipeline_call_count
+        columns = []
+        if pipeline_name in SUPPORTED_MULTIMODAL_PIPELINES:
+            columns += SUPPORTED_MULTIMODAL_PIPELINES[pipeline_name]["table-schema"]
+        else:
+            wandb.Error("Pipeline not supported for logging")
+        self.wandb_table = wandb.Table(columns=columns)
+
+    def __call__(
+        self,
+        args: Sequence[Any],
+        kwargs: Dict[str, Any],
+        response: Response,
+        start_time: float,
+        time_elapsed: float,
+    ) -> Any:
+        """Main call method for the `DiffusersPipelineResolver` class.
+
+        Args:
+            args: (Sequence[Any]) List of arguments.
+            kwargs: (Dict[str, Any]) Dictionary of keyword arguments.
+            response: (wandb.sdk.integration_utils.auto_logging.Response) The response from
+                the request.
+            start_time: (float) Time when request started.
+            time_elapsed: (float) Time elapsed for the request.
+
+        Returns:
+            Packed data as a dictionary for logging to wandb, None if an exception occurred.
+        """
+        try:
+            # Get the pipeline and the args
+            pipeline, args = args[0], args[1:]
+
+            # Update the Kwargs so that they can be logged easily
+            kwargs = get_updated_kwargs(pipeline, args, kwargs)
+
+            # Get the pipeline configs
+            pipeline_configs = dict(pipeline.config)
+            pipeline_configs["pipeline-name"] = self.pipeline_name
+
+            if "workflow" not in wandb.config:
+                wandb.config.update(
+                    {
+                        "workflow": [
+                            {
+                                "pipeline": pipeline_configs,
+                                "params": kwargs,
+                                "stage": f"Pipeline-Call-{self.pipeline_call_count}",
+                            }
+                        ]
+                    }
+                )
+            else:
+                existing_workflow = wandb.config.workflow
+                updated_workflow = existing_workflow + [
+                    {
+                        "pipeline": pipeline_configs,
+                        "params": kwargs,
+                        "stage": f"Pipeline-Call-{self.pipeline_call_count}",
+                    }
+                ]
+                wandb.config.update(
+                    {"workflow": updated_workflow}, allow_val_change=True
+                )
+
+            # Return the WandB loggable dict
+            loggable_dict = self.prepare_loggable_dict(pipeline, response, kwargs)
+            return loggable_dict
+        except Exception as e:
+            logger.warning(e)
+        return None
+
+    def get_output_images(self, response: Response) -> List:
+        """Unpack the generated images, audio, video, etc. from the Diffusion Pipeline's response.
+
+        Args:
+            response: (wandb.sdk.integration_utils.auto_logging.Response) The response from
+                the request.
+
+        Returns:
+            List of generated images, audio, video, etc.
+        """
+        if "output-type" not in SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]:
+            return response.images
+        else:
+            if (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "video"
+            ):
+                if self.pipeline_name in ["ShapEPipeline"]:
+                    return response.images
+                return response.frames
+            elif (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "audio"
+            ):
+                return response.audios
+
+    def log_media(self, image: Any, loggable_kwarg_chunks: List, idx: int) -> None:
+        """Log the generated images, audio, video, etc. from the Diffusion Pipeline's response along with an optional caption to a media panel in the run.
+
+        Args:
+            image: (Any) The generated images, audio, video, etc. from the Diffusion
+                Pipeline's response.
+            loggable_kwarg_chunks: (List) Loggable chunks of kwargs.
+        """
+        if "output-type" not in SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]:
+            try:
+                caption = ""
+                if self.pipeline_name in [
+                    "StableDiffusionXLPipeline",
+                    "StableDiffusionXLImg2ImgPipeline",
+                ]:
+                    prompt_index = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                        "kwarg-logging"
+                    ].index("prompt")
+                    prompt2_index = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                        "kwarg-logging"
+                    ].index("prompt_2")
+                    caption = f"Prompt-1: {loggable_kwarg_chunks[prompt_index][idx]}\nPrompt-2: {loggable_kwarg_chunks[prompt2_index][idx]}"
+                else:
+                    prompt_index = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                        "kwarg-logging"
+                    ].index("prompt")
+                    caption = loggable_kwarg_chunks[prompt_index][idx]
+            except ValueError:
+                caption = None
+            wandb.log(
+                {
+                    f"Generated-Image/Pipeline-Call-{self.pipeline_call_count}": wandb.Image(
+                        image, caption=caption
+                    )
+                }
+            )
+        else:
+            if (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "video"
+            ):
+                try:
+                    prompt_index = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                        "kwarg-logging"
+                    ].index("prompt")
+                    caption = loggable_kwarg_chunks[prompt_index][idx]
+                except ValueError:
+                    caption = None
+                wandb.log(
+                    {
+                        f"Generated-Video/Pipeline-Call-{self.pipeline_call_count}": wandb.Video(
+                            postprocess_pils_to_np(image), fps=4, caption=caption
+                        )
+                    }
+                )
+            elif (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "audio"
+            ):
+                try:
+                    prompt_index = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                        "kwarg-logging"
+                    ].index("prompt")
+                    caption = loggable_kwarg_chunks[prompt_index][idx]
+                except ValueError:
+                    caption = None
+                wandb.log(
+                    {
+                        f"Generated-Audio/Pipeline-Call-{self.pipeline_call_count}": wandb.Audio(
+                            image, sample_rate=16000, caption=caption
+                        )
+                    }
+                )
+
+    def add_data_to_table(
+        self, image: Any, loggable_kwarg_chunks: List, idx: int
+    ) -> None:
+        """Populate the row of the `wandb.Table`.
+
+        Args:
+            image: (Any) The generated images, audio, video, etc. from the Diffusion
+                Pipeline's response.
+            loggable_kwarg_chunks: (List) Loggable chunks of kwargs.
+            idx: (int) Chunk index.
+        """
+        table_row = []
+        kwarg_actions = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+            "kwarg-actions"
+        ]
+        for column_idx, loggable_kwarg_chunk in enumerate(loggable_kwarg_chunks):
+            if kwarg_actions[column_idx] is None:
+                table_row.append(
+                    loggable_kwarg_chunk[idx]
+                    if loggable_kwarg_chunk[idx] is not None
+                    else ""
+                )
+            else:
+                table_row.append(kwarg_actions[column_idx](loggable_kwarg_chunk[idx]))
+        if "output-type" not in SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]:
+            table_row.append(wandb.Image(image))
+        else:
+            if (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "video"
+            ):
+                table_row.append(wandb.Video(postprocess_pils_to_np(image), fps=4))
+            elif (
+                SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name]["output-type"]
+                == "audio"
+            ):
+                table_row.append(wandb.Audio(image, sample_rate=16000))
+        self.wandb_table.add_data(*table_row)
+
+    def prepare_loggable_dict(
+        self, pipeline: Any, response: Response, kwargs: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Prepare the loggable dictionary, which is the packed data as a dictionary for logging to wandb, None if an exception occurred.
+
+        Args:
+            pipeline: (Any) The Diffusion Pipeline.
+            response: (wandb.sdk.integration_utils.auto_logging.Response) The response from
+                the request.
+            kwargs: (Dict[str, Any]) Dictionary of keyword arguments.
+
+        Returns:
+            Packed data as a dictionary for logging to wandb, None if an exception occurred.
+        """
+        # Unpack the generated images, audio, video, etc. from the Diffusion Pipeline's response.
+        images = self.get_output_images(response)
+        if (
+            self.pipeline_name == "StableDiffusionXLPipeline"
+            and kwargs["output_type"] == "latent"
+        ):
+            images = decode_sdxl_t2i_latents(pipeline, response.images)
+
+        # Account for exception pipelines for text-to-video
+        if self.pipeline_name in ["TextToVideoSDPipeline", "TextToVideoZeroPipeline"]:
+            video = postprocess_np_arrays_for_video(
+                images, normalize=self.pipeline_name == "TextToVideoZeroPipeline"
+            )
+            wandb.log(
+                {
+                    f"Generated-Video/Pipeline-Call-{self.pipeline_call_count}": wandb.Video(
+                        video, fps=4, caption=kwargs["prompt"]
+                    )
+                }
+            )
+            loggable_kwarg_ids = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                "kwarg-logging"
+            ]
+            table_row = [
+                kwargs[loggable_kwarg_ids[idx]]
+                for idx in range(len(loggable_kwarg_ids))
+            ]
+            table_row.append(wandb.Video(video, fps=4))
+            self.wandb_table.add_data(*table_row)
+        else:
+            loggable_kwarg_ids = SUPPORTED_MULTIMODAL_PIPELINES[self.pipeline_name][
+                "kwarg-logging"
+            ]
+            # chunkify loggable kwargs
+            loggable_kwarg_chunks = []
+            for loggable_kwarg_id in loggable_kwarg_ids:
+                loggable_kwarg_chunks.append(
+                    kwargs[loggable_kwarg_id]
+                    if isinstance(kwargs[loggable_kwarg_id], list)
+                    else [kwargs[loggable_kwarg_id]]
+                )
+            # chunkify the generated media
+            images = chunkify(images, len(loggable_kwarg_chunks[0]))
+            for idx in range(len(loggable_kwarg_chunks[0])):
+                for image in images[idx]:
+                    # Log media to media panel
+                    self.log_media(image, loggable_kwarg_chunks, idx)
+                    # Populate the row of the wandb_table
+                    self.add_data_to_table(image, loggable_kwarg_chunks, idx)
+        return {
+            f"Result-Table/Pipeline-Call-{self.pipeline_call_count}": self.wandb_table
+        }

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/diffusers/resolvers/utils.py

@@ -0,0 +1,102 @@
+import inspect
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+
+import wandb
+from wandb.util import get_module
+
+if TYPE_CHECKING:
+    np_array = get_module("numpy.array")
+    torch_float_tensor = get_module("torch.FloatTensor")
+
+
+def chunkify(input_list, chunk_size) -> List:
+    chunk_size = max(1, chunk_size)
+    return [
+        input_list[i : i + chunk_size] for i in range(0, len(input_list), chunk_size)
+    ]
+
+
+def get_updated_kwargs(
+    pipeline: Any, args: Sequence[Any], kwargs: Dict[str, Any]
+) -> Dict[str, Any]:
+    pipeline_call_parameters = list(
+        inspect.signature(pipeline.__call__).parameters.items()
+    )
+    for idx, arg in enumerate(args):
+        kwargs[pipeline_call_parameters[idx][0]] = arg
+    for pipeline_parameter in pipeline_call_parameters:
+        if pipeline_parameter[0] not in kwargs:
+            kwargs[pipeline_parameter[0]] = pipeline_parameter[1].default
+    if "generator" in kwargs:
+        generator = kwargs["generator"]
+        kwargs["generator"] = (
+            {
+                "seed": generator.initial_seed(),
+                "device": generator.device,
+                "random_state": generator.get_state().cpu().numpy().tolist(),
+            }
+            if generator is not None
+            else None
+        )
+    if "ip_adapter_image" in kwargs:
+        if kwargs["ip_adapter_image"] is not None:
+            wandb.log({"IP-Adapter-Image": wandb.Image(kwargs["ip_adapter_image"])})
+    return kwargs
+
+
+def postprocess_pils_to_np(image: List) -> "np_array":
+    np = get_module(
+        "numpy",
+        required="Please ensure NumPy is installed. You can run `pip install numpy` to install it.",
+    )
+    return np.stack(
+        [np.transpose(np.array(img).astype("uint8"), axes=(2, 0, 1)) for img in image],
+        axis=0,
+    )
+
+
+def postprocess_np_arrays_for_video(
+    images: List["np_array"], normalize: Optional[bool] = False
+) -> "np_array":
+    np = get_module(
+        "numpy",
+        required="Please ensure NumPy is installed. You can run `pip install numpy` to install it.",
+    )
+    images = [(img * 255).astype("uint8") for img in images] if normalize else images
+    return np.transpose(np.stack((images), axis=0), axes=(0, 3, 1, 2))
+
+
+def decode_sdxl_t2i_latents(pipeline: Any, latents: "torch_float_tensor") -> List:
+    """Decode latents generated by [`diffusers.StableDiffusionXLPipeline`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#stable-diffusion-xl).
+
+    Args:
+        pipeline: (diffusers.DiffusionPipeline) The Diffusion Pipeline from
+            [`diffusers`](https://huggingface.co/docs/diffusers).
+        latents (torch.FloatTensor): The generated latents.
+
+    Returns:
+        List of `PIL` images corresponding to the generated latents.
+    """
+    torch = get_module(
+        "torch",
+        required="Please ensure PyTorch is installed. You can check out https://pytorch.org/get-started/locally/#start-locally for installation instructions.",
+    )
+    with torch.no_grad():
+        needs_upcasting = (
+            pipeline.vae.dtype == torch.float16 and pipeline.vae.config.force_upcast
+        )
+        if needs_upcasting:
+            pipeline.upcast_vae()
+            latents = latents.to(
+                next(iter(pipeline.vae.post_quant_conv.parameters())).dtype
+            )
+        images = pipeline.vae.decode(
+            latents / pipeline.vae.config.scaling_factor, return_dict=False
+        )[0]
+        if needs_upcasting:
+            pipeline.vae.to(dtype=torch.float16)
+        if pipeline.watermark is not None:
+            images = pipeline.watermark.apply_watermark(images)
+        images = pipeline.image_processor.postprocess(images, output_type="pil")
+        pipeline.maybe_free_model_hooks()
+        return images

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/__init__.py

@@ -0,0 +1,11 @@
+"""Tools for integrating `wandb` with [`Keras`](https://keras.io/)."""
+
+__all__ = (
+    "WandbCallback",
+    "WandbMetricsLogger",
+    "WandbModelCheckpoint",
+    "WandbEvalCallback",
+)
+
+from .callbacks import WandbEvalCallback, WandbMetricsLogger, WandbModelCheckpoint
+from .keras import WandbCallback  # TODO: legacy callback to be deprecated

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/callbacks/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ("WandbMetricsLogger", "WandbModelCheckpoint", "WandbEvalCallback")
+
+from .metrics_logger import WandbMetricsLogger
+from .model_checkpoint import WandbModelCheckpoint
+from .tables_builder import WandbEvalCallback

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/callbacks/metrics_logger.py

@@ -0,0 +1,129 @@
+from typing import Any, Dict, Literal, Optional, Union
+
+import tensorflow as tf  # type: ignore
+from tensorflow.keras import callbacks
+
+import wandb
+from wandb.integration.keras.keras import patch_tf_keras
+from wandb.sdk.lib import telemetry
+
+LogStrategy = Literal["epoch", "batch"]
+
+
+patch_tf_keras()
+
+
+class WandbMetricsLogger(callbacks.Callback):
+    """Logger that sends system metrics to W&B.
+
+    `WandbMetricsLogger` automatically logs the `logs` dictionary that callback methods
+    take as argument to wandb.
+
+    This callback automatically logs the following to a W&B run page:
+    * system (CPU/GPU/TPU) metrics,
+    * train and validation metrics defined in `model.compile`,
+    * learning rate (both for a fixed value or a learning rate scheduler)
+
+    Notes:
+    If you resume training by passing `initial_epoch` to `model.fit` and you are using a
+    learning rate scheduler, make sure to pass `initial_global_step` to
+    `WandbMetricsLogger`. The `initial_global_step` is `step_size * initial_step`, where
+    `step_size` is number of training steps per epoch. `step_size` can be calculated as
+    the product of the cardinality of the training dataset and the batch size.
+
+    Args:
+        log_freq: ("epoch", "batch", or int) if "epoch", logs metrics
+            at the end of each epoch. If "batch", logs metrics at the end
+            of each batch. If an integer, logs metrics at the end of that
+            many batches. Defaults to "epoch".
+        initial_global_step: (int) Use this argument to correctly log the
+            learning rate when you resume training from some `initial_epoch`,
+            and a learning rate scheduler is used. This can be computed as
+            `step_size * initial_step`. Defaults to 0.
+    """
+
+    def __init__(
+        self,
+        log_freq: Union[LogStrategy, int] = "epoch",
+        initial_global_step: int = 0,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` before WandbMetricsLogger()"
+            )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_metrics_logger = True
+
+        if log_freq == "batch":
+            log_freq = 1
+
+        self.logging_batch_wise = isinstance(log_freq, int)
+        self.log_freq: Any = log_freq if self.logging_batch_wise else None
+        self.global_batch = 0
+        self.global_step = initial_global_step
+
+        if self.logging_batch_wise:
+            # define custom x-axis for batch logging.
+            wandb.define_metric("batch/batch_step")
+            # set all batch metrics to be logged against batch_step.
+            wandb.define_metric("batch/*", step_metric="batch/batch_step")
+        else:
+            # define custom x-axis for epoch-wise logging.
+            wandb.define_metric("epoch/epoch")
+            # set all epoch-wise metrics to be logged against epoch.
+            wandb.define_metric("epoch/*", step_metric="epoch/epoch")
+
+    def _get_lr(self) -> Union[float, None]:
+        if isinstance(
+            self.model.optimizer.learning_rate,
+            (tf.Variable, tf.Tensor),
+        ) or (
+            hasattr(self.model.optimizer.learning_rate, "shape")
+            and self.model.optimizer.learning_rate.shape == ()
+        ):
+            return float(self.model.optimizer.learning_rate.numpy().item())
+        try:
+            return float(
+                self.model.optimizer.learning_rate(step=self.global_step).numpy().item()
+            )
+        except Exception as e:
+            wandb.termerror(f"Unable to log learning rate: {e}", repeat=False)
+            return None
+
+    def on_epoch_end(self, epoch: int, logs: Optional[Dict[str, Any]] = None) -> None:
+        """Called at the end of an epoch."""
+        logs = dict() if logs is None else {f"epoch/{k}": v for k, v in logs.items()}
+
+        logs["epoch/epoch"] = epoch
+
+        lr = self._get_lr()
+        if lr is not None:
+            logs["epoch/learning_rate"] = lr
+
+        wandb.log(logs)
+
+    def on_batch_end(self, batch: int, logs: Optional[Dict[str, Any]] = None) -> None:
+        self.global_step += 1
+        """An alias for `on_train_batch_end` for backwards compatibility."""
+        if self.logging_batch_wise and batch % self.log_freq == 0:
+            logs = {f"batch/{k}": v for k, v in logs.items()} if logs else {}
+            logs["batch/batch_step"] = self.global_batch
+
+            lr = self._get_lr()
+            if lr is not None:
+                logs["batch/learning_rate"] = lr
+
+            wandb.log(logs)
+
+            self.global_batch += self.log_freq
+
+    def on_train_batch_end(
+        self, batch: int, logs: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """Called at the end of a training batch in `fit` methods."""
+        self.on_batch_end(batch, logs if logs else {})

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/callbacks/model_checkpoint.py

@@ -0,0 +1,188 @@
+import os
+import string
+from typing import Any, Dict, List, Literal, Optional, Union
+
+import tensorflow as tf  # type: ignore
+from tensorflow.keras import callbacks  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry
+from wandb.sdk.lib.paths import StrPath
+
+from ..keras import patch_tf_keras
+
+Mode = Literal["auto", "min", "max"]
+SaveStrategy = Literal["epoch"]
+
+patch_tf_keras()
+
+
+class WandbModelCheckpoint(callbacks.ModelCheckpoint):
+    """A checkpoint that periodically saves a Keras model or model weights.
+
+    Saved weights are uploaded to W&B as a `wandb.Artifact`.
+
+    Since this callback is subclassed from `tf.keras.callbacks.ModelCheckpoint`, the
+    checkpointing logic is taken care of by the parent callback. You can learn more
+    here: https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/ModelCheckpoint
+
+    This callback is to be used in conjunction with training using `model.fit()` to save
+    a model or weights (in a checkpoint file) at some interval. The model checkpoints
+    will be logged as W&B Artifacts. You can learn more here:
+    https://docs.wandb.ai/guides/artifacts
+
+    This callback provides the following features:
+        - Save the model that has achieved "best performance" based on "monitor".
+        - Save the model at the end of every epoch regardless of the performance.
+        - Save the model at the end of epoch or after a fixed number of training batches.
+        - Save only model weights, or save the whole model.
+        - Save the model either in SavedModel format or in `.h5` format.
+
+    Args:
+        filepath: (Union[str, os.PathLike]) path to save the model file. `filepath`
+            can contain named formatting options, which will be filled by the value
+            of `epoch` and keys in `logs` (passed in `on_epoch_end`). For example:
+            if `filepath` is `model-{epoch:02d}-{val_loss:.2f}`, then the
+            model checkpoints will be saved with the epoch number and the
+            validation loss in the filename.
+        monitor: (str) The metric name to monitor. Default to "val_loss".
+        verbose: (int) Verbosity mode, 0 or 1. Mode 0 is silent, and mode 1
+            displays messages when the callback takes an action.
+        save_best_only: (bool) if `save_best_only=True`, it only saves when the model
+            is considered the "best" and the latest best model according to the
+            quantity monitored will not be overwritten. If `filepath` doesn't contain
+            formatting options like `{epoch}` then `filepath` will be overwritten by
+            each new better model locally. The model logged as an artifact will still be
+            associated with the correct `monitor`.  Artifacts will be uploaded
+            continuously and versioned separately as a new best model is found.
+        save_weights_only: (bool) if True, then only the model's weights will be saved.
+        mode: (Mode) one of {'auto', 'min', 'max'}. For `val_acc`, this should be `max`,
+            for `val_loss` this should be `min`, etc.
+        save_freq: (Union[SaveStrategy, int]) `epoch` or integer. When using `'epoch'`,
+            the callback saves the model after each epoch. When using an integer, the
+            callback saves the model at end of this many batches.
+            Note that when monitoring validation metrics such as `val_acc` or `val_loss`,
+            save_freq must be set to "epoch" as those metrics are only available at the
+            end of an epoch.
+        initial_value_threshold: (Optional[float]) Floating point initial "best" value of the metric
+            to be monitored.
+    """
+
+    def __init__(
+        self,
+        filepath: StrPath,
+        monitor: str = "val_loss",
+        verbose: int = 0,
+        save_best_only: bool = False,
+        save_weights_only: bool = False,
+        mode: Mode = "auto",
+        save_freq: Union[SaveStrategy, int] = "epoch",
+        initial_value_threshold: Optional[float] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(
+            filepath=filepath,
+            monitor=monitor,
+            verbose=verbose,
+            save_best_only=save_best_only,
+            save_weights_only=save_weights_only,
+            mode=mode,
+            save_freq=save_freq,
+            initial_value_threshold=initial_value_threshold,
+            **kwargs,
+        )
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` before `WandbModelCheckpoint()`"
+            )
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_model_checkpoint = True
+
+        self.save_weights_only = save_weights_only
+
+        # User-friendly warning when trying to save the best model.
+        if self.save_best_only:
+            self._check_filepath()
+
+        self._is_old_tf_keras_version: Optional[bool] = None
+
+    def on_train_batch_end(
+        self, batch: int, logs: Optional[Dict[str, float]] = None
+    ) -> None:
+        if self._should_save_on_batch(batch):
+            if self.is_old_tf_keras_version:
+                # Save the model and get filepath
+                self._save_model(epoch=self._current_epoch, logs=logs)
+                filepath = self._get_file_path(epoch=self._current_epoch, logs=logs)
+            else:
+                # Save the model and get filepath
+                self._save_model(epoch=self._current_epoch, batch=batch, logs=logs)
+                filepath = self._get_file_path(
+                    epoch=self._current_epoch, batch=batch, logs=logs
+                )
+            # Log the model as artifact
+            aliases = ["latest", f"epoch_{self._current_epoch}_batch_{batch}"]
+            self._log_ckpt_as_artifact(filepath, aliases=aliases)
+
+    def on_epoch_end(self, epoch: int, logs: Optional[Dict[str, float]] = None) -> None:
+        super().on_epoch_end(epoch, logs)
+        # Check if model checkpoint is created at the end of epoch.
+        if self.save_freq == "epoch":
+            # Get filepath where the model checkpoint is saved.
+            if self.is_old_tf_keras_version:
+                filepath = self._get_file_path(epoch=epoch, logs=logs)
+            else:
+                filepath = self._get_file_path(epoch=epoch, batch=None, logs=logs)
+            # Log the model as artifact
+            aliases = ["latest", f"epoch_{epoch}"]
+            self._log_ckpt_as_artifact(filepath, aliases=aliases)
+
+    def _log_ckpt_as_artifact(
+        self, filepath: str, aliases: Optional[List[str]] = None
+    ) -> None:
+        """Log model checkpoint as  W&B Artifact."""
+        try:
+            assert wandb.run is not None
+            model_checkpoint_artifact = wandb.Artifact(
+                f"run_{wandb.run.id}_model", type="model"
+            )
+            if os.path.isfile(filepath):
+                model_checkpoint_artifact.add_file(filepath)
+            elif os.path.isdir(filepath):
+                model_checkpoint_artifact.add_dir(filepath)
+            else:
+                raise FileNotFoundError(f"No such file or directory {filepath}")
+            wandb.log_artifact(model_checkpoint_artifact, aliases=aliases or [])
+        except ValueError:
+            # This error occurs when `save_best_only=True` and the model
+            # checkpoint is not saved for that epoch/batch. Since TF/Keras
+            # is giving friendly log, we can avoid clustering the stdout.
+            pass
+
+    def _check_filepath(self) -> None:
+        placeholders = []
+        for tup in string.Formatter().parse(self.filepath):
+            if tup[1] is not None:
+                placeholders.append(tup[1])
+        if len(placeholders) == 0:
+            wandb.termwarn(
+                "When using `save_best_only`, ensure that the `filepath` argument "
+                "contains formatting placeholders like `{epoch:02d}` or `{batch:02d}`. "
+                "This ensures correct interpretation of the logged artifacts.",
+                repeat=False,
+            )
+
+    @property
+    def is_old_tf_keras_version(self) -> Optional[bool]:
+        if self._is_old_tf_keras_version is None:
+            from wandb.util import parse_version
+
+            try:
+                if parse_version(tf.keras.__version__) < parse_version("2.6.0"):
+                    self._is_old_tf_keras_version = True
+                else:
+                    self._is_old_tf_keras_version = False
+            except AttributeError:
+                self._is_old_tf_keras_version = False
+
+        return self._is_old_tf_keras_version

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/callbacks/tables_builder.py

@@ -0,0 +1,228 @@
+import abc
+from typing import Any, Dict, List, Optional
+
+from tensorflow.keras.callbacks import Callback  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry
+
+
+class WandbEvalCallback(Callback, abc.ABC):
+    """Abstract base class to build Keras callbacks for model prediction visualization.
+
+    You can build callbacks for visualizing model predictions `on_epoch_end`
+    that can be passed to `model.fit()` for classification, object detection,
+    segmentation, etc. tasks.
+
+    To use this, inherit from this base callback class and implement the
+    `add_ground_truth` and `add_model_prediction` methods.
+
+    The base class will take care of the following:
+    - Initialize `data_table` for logging the ground truth and
+        `pred_table` for predictions.
+    - The data uploaded to `data_table` is used as a reference for the
+        `pred_table`. This is to reduce the memory footprint. The `data_table_ref`
+        is a list that can be used to access the referenced data.
+        Check out the example below to see how it's done.
+    - Log the tables to W&B as W&B Artifacts.
+    - Each new `pred_table` is logged as a new version with aliases.
+
+    Example:
+        ```python
+        class WandbClfEvalCallback(WandbEvalCallback):
+            def __init__(self, validation_data, data_table_columns, pred_table_columns):
+                super().__init__(data_table_columns, pred_table_columns)
+
+                self.x = validation_data[0]
+                self.y = validation_data[1]
+
+            def add_ground_truth(self):
+                for idx, (image, label) in enumerate(zip(self.x, self.y)):
+                    self.data_table.add_data(idx, wandb.Image(image), label)
+
+            def add_model_predictions(self, epoch):
+                preds = self.model.predict(self.x, verbose=0)
+                preds = tf.argmax(preds, axis=-1)
+
+                data_table_ref = self.data_table_ref
+                table_idxs = data_table_ref.get_index()
+
+                for idx in table_idxs:
+                    pred = preds[idx]
+                    self.pred_table.add_data(
+                        epoch,
+                        data_table_ref.data[idx][0],
+                        data_table_ref.data[idx][1],
+                        data_table_ref.data[idx][2],
+                        pred,
+                    )
+
+
+        model.fit(
+            x,
+            y,
+            epochs=2,
+            validation_data=(x, y),
+            callbacks=[
+                WandbClfEvalCallback(
+                    validation_data=(x, y),
+                    data_table_columns=["idx", "image", "label"],
+                    pred_table_columns=["epoch", "idx", "image", "label", "pred"],
+                )
+            ],
+        )
+        ```
+
+    To have more fine-grained control, you can override the `on_train_begin` and
+    `on_epoch_end` methods. If you want to log the samples after N batched, you
+    can implement `on_train_batch_end` method.
+    """
+
+    def __init__(
+        self,
+        data_table_columns: List[str],
+        pred_table_columns: List[str],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if wandb.run is None:
+            raise wandb.Error(
+                "You must call `wandb.init()` first before using this callback."
+            )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras_wandb_eval_callback = True
+
+        self.data_table_columns = data_table_columns
+        self.pred_table_columns = pred_table_columns
+
+    def on_train_begin(self, logs: Optional[Dict[str, float]] = None) -> None:
+        # Initialize the data_table
+        self.init_data_table(column_names=self.data_table_columns)
+        # Log the ground truth data
+        self.add_ground_truth(logs)
+        # Log the data_table as W&B Artifacts
+        self.log_data_table()
+
+    def on_epoch_end(self, epoch: int, logs: Optional[Dict[str, float]] = None) -> None:
+        # Initialize the pred_table
+        self.init_pred_table(column_names=self.pred_table_columns)
+        # Log the model prediction
+        self.add_model_predictions(epoch, logs)
+        # Log the pred_table as W&B Artifacts
+        self.log_pred_table()
+
+    @abc.abstractmethod
+    def add_ground_truth(self, logs: Optional[Dict[str, float]] = None) -> None:
+        """Add ground truth data to `data_table`.
+
+        Use this method to write the logic for adding validation/training data to
+        `data_table` initialized using `init_data_table` method.
+
+        Example:
+            ```python
+            for idx, data in enumerate(dataloader):
+                self.data_table.add_data(idx, data)
+            ```
+        This method is called once `on_train_begin` or equivalent hook.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.add_ground_truth")
+
+    @abc.abstractmethod
+    def add_model_predictions(
+        self, epoch: int, logs: Optional[Dict[str, float]] = None
+    ) -> None:
+        """Add a prediction from a model to `pred_table`.
+
+        Use this method to write the logic for adding model prediction for validation/
+        training data to `pred_table` initialized using `init_pred_table` method.
+
+        Example:
+            ```python
+            # Assuming the dataloader is not shuffling the samples.
+            for idx, data in enumerate(dataloader):
+                preds = model.predict(data)
+                self.pred_table.add_data(
+                    self.data_table_ref.data[idx][0],
+                    self.data_table_ref.data[idx][1],
+                    preds,
+                )
+            ```
+        This method is called `on_epoch_end` or equivalent hook.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__}.add_model_predictions")
+
+    def init_data_table(self, column_names: List[str]) -> None:
+        """Initialize the W&B Tables for validation data.
+
+        Call this method `on_train_begin` or equivalent hook. This is followed by adding
+        data to the table row or column wise.
+
+        Args:
+            column_names: (list) Column names for W&B Tables.
+        """
+        self.data_table = wandb.Table(columns=column_names, allow_mixed_types=True)
+
+    def init_pred_table(self, column_names: List[str]) -> None:
+        """Initialize the W&B Tables for model evaluation.
+
+        Call this method `on_epoch_end` or equivalent hook. This is followed by adding
+        data to the table row or column wise.
+
+        Args:
+            column_names: (list) Column names for W&B Tables.
+        """
+        self.pred_table = wandb.Table(columns=column_names)
+
+    def log_data_table(
+        self, name: str = "val", type: str = "dataset", table_name: str = "val_data"
+    ) -> None:
+        """Log the `data_table` as W&B artifact and call `use_artifact` on it.
+
+        This lets the evaluation table use the reference of already uploaded data
+        (images, text, scalar, etc.) without re-uploading.
+
+        Args:
+            name: (str) A human-readable name for this artifact, which is how you can
+                identify this artifact in the UI or reference it in use_artifact calls.
+                (default is 'val')
+            type: (str) The type of the artifact, which is used to organize and
+                differentiate artifacts. (default is 'dataset')
+            table_name: (str) The name of the table as will be displayed in the UI.
+                (default is 'val_data').
+        """
+        data_artifact = wandb.Artifact(name, type=type)
+        data_artifact.add(self.data_table, table_name)
+
+        # Calling `use_artifact` uploads the data to W&B.
+        assert wandb.run is not None
+        wandb.run.use_artifact(data_artifact)
+        data_artifact.wait()
+
+        # We get the reference table.
+        self.data_table_ref = data_artifact.get(table_name)
+
+    def log_pred_table(
+        self,
+        type: str = "evaluation",
+        table_name: str = "eval_data",
+        aliases: Optional[List[str]] = None,
+    ) -> None:
+        """Log the W&B Tables for model evaluation.
+
+        The table will be logged multiple times creating new version. Use this
+        to compare models at different intervals interactively.
+
+        Args:
+            type: (str) The type of the artifact, which is used to organize and
+                differentiate artifacts. (default is 'evaluation')
+            table_name: (str) The name of the table as will be displayed in the UI.
+                (default is 'eval_data')
+            aliases: (List[str]) List of aliases for the prediction table.
+        """
+        assert wandb.run is not None
+        pred_artifact = wandb.Artifact(f"run_{wandb.run.id}_pred", type=type)
+        pred_artifact.add(self.pred_table, table_name)
+        wandb.run.log_artifact(pred_artifact, aliases=aliases or ["latest"])

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/keras/keras.py

@@ -0,0 +1,1091 @@
+"""keras init."""
+
+import logging
+import operator
+import os
+import shutil
+import sys
+from itertools import chain
+
+import numpy as np
+import tensorflow as tf
+import tensorflow.keras.backend as K  # noqa: N812
+
+import wandb
+from wandb.sdk.integration_utils.data_logging import ValidationDataLogger
+from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.util import add_import_hook
+
+
+def _check_keras_version():
+    from keras import __version__ as keras_version
+
+    from wandb.util import parse_version
+
+    if parse_version(keras_version) < parse_version("2.4.0"):
+        wandb.termwarn(
+            f"Keras version {keras_version} is not fully supported. Required keras >= 2.4.0"
+        )
+
+
+def _can_compute_flops() -> bool:
+    """FLOPS computation is restricted to TF 2.x as it requires tf.compat.v1."""
+    from wandb.util import parse_version
+
+    if parse_version(tf.__version__) >= parse_version("2.0.0"):
+        return True
+
+    return False
+
+
+if "keras" in sys.modules:
+    _check_keras_version()
+else:
+    add_import_hook("keras", _check_keras_version)
+
+
+logger = logging.getLogger(__name__)
+
+
+def is_dataset(data):
+    dataset_ops = wandb.util.get_module("tensorflow.python.data.ops.dataset_ops")
+    if dataset_ops and hasattr(dataset_ops, "DatasetV2"):
+        dataset_types = (dataset_ops.DatasetV2,)
+        if hasattr(dataset_ops, "DatasetV1"):
+            dataset_types = dataset_types + (dataset_ops.DatasetV1,)
+        return isinstance(data, dataset_types)
+    else:
+        return False
+
+
+def is_generator_like(data):
+    # Checks if data is a generator, Sequence, or Iterator.
+
+    types = (tf.keras.utils.Sequence,)
+    iterator_ops = wandb.util.get_module("tensorflow.python.data.ops.iterator_ops")
+    if iterator_ops:
+        types = types + (iterator_ops.Iterator,)
+        # EagerIterator was in tensorflow < 2
+        if hasattr(iterator_ops, "EagerIterator"):
+            types = types + (iterator_ops.EagerIterator,)
+        elif hasattr(iterator_ops, "IteratorV2"):
+            types = types + (iterator_ops.IteratorV2,)
+    return hasattr(data, "next") or hasattr(data, "__next__") or isinstance(data, types)
+
+
+def patch_tf_keras():  # noqa: C901
+    from tensorflow.python.eager import context
+
+    from wandb.util import parse_version
+
+    if (
+        parse_version("2.6.0")
+        <= parse_version(tf.__version__)
+        < parse_version("2.13.0")
+    ):
+        keras_engine = "keras.engine"
+        try:
+            from keras.engine import training
+            from keras.engine import training_arrays_v1 as training_arrays
+            from keras.engine import training_generator_v1 as training_generator
+        except (ImportError, AttributeError):
+            wandb.termerror("Unable to patch Tensorflow/Keras")
+            logger.exception("exception while trying to patch_tf_keras")
+            return
+    else:
+        keras_engine = "tensorflow.python.keras.engine"
+
+        from tensorflow.python.keras.engine import training
+
+        try:
+            from tensorflow.python.keras.engine import (
+                training_arrays_v1 as training_arrays,
+            )
+            from tensorflow.python.keras.engine import (
+                training_generator_v1 as training_generator,
+            )
+        except (ImportError, AttributeError):
+            try:
+                from tensorflow.python.keras.engine import (
+                    training_arrays,
+                    training_generator,
+                )
+            except (ImportError, AttributeError):
+                wandb.termerror("Unable to patch Tensorflow/Keras")
+                logger.exception("exception while trying to patch_tf_keras")
+                return
+
+    # Tensorflow 2.1
+    training_v2_1 = wandb.util.get_module("tensorflow.python.keras.engine.training_v2")
+    # Tensorflow 2.2
+    training_v2_2 = wandb.util.get_module(f"{keras_engine}.training_v1")
+
+    if training_v2_1:
+        old_v2 = training_v2_1.Loop.fit
+    elif training_v2_2:
+        old_v2 = training.Model.fit
+
+    old_arrays = training_arrays.fit_loop
+    old_generator = training_generator.fit_generator
+
+    def set_wandb_attrs(cbk, val_data):
+        if isinstance(cbk, WandbCallback):
+            if is_generator_like(val_data):
+                cbk.generator = val_data
+            elif is_dataset(val_data):
+                if context.executing_eagerly():
+                    cbk.generator = iter(val_data)
+                else:
+                    wandb.termwarn(
+                        "Found a validation dataset in graph mode, can't patch Keras."
+                    )
+            elif isinstance(val_data, tuple) and isinstance(val_data[0], tf.Tensor):
+                # Graph mode dataset generator
+                def gen():
+                    while True:
+                        yield K.get_session().run(val_data)
+
+                cbk.generator = gen()
+            else:
+                cbk.validation_data = val_data
+
+    def new_arrays(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_inputs = kwargs.get("val_inputs")
+        val_targets = kwargs.get("val_targets")
+        # TODO: these could be generators, why index 0?
+        if val_inputs and val_targets:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, (val_inputs[0], val_targets[0]))
+        return old_arrays(*args, **kwargs)
+
+    def new_generator(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_data = kwargs.get("validation_data")
+        if val_data:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, val_data)
+        return old_generator(*args, **kwargs)
+
+    def new_v2(*args, **kwargs):
+        cbks = kwargs.get("callbacks", [])
+        val_data = kwargs.get("validation_data")
+        if val_data:
+            for cbk in cbks:
+                set_wandb_attrs(cbk, val_data)
+        return old_v2(*args, **kwargs)
+
+    training_arrays.orig_fit_loop = old_arrays
+    training_arrays.fit_loop = new_arrays
+    training_generator.orig_fit_generator = old_generator
+    training_generator.fit_generator = new_generator
+    wandb.patched["keras"].append([f"{keras_engine}.training_arrays", "fit_loop"])
+    wandb.patched["keras"].append(
+        [f"{keras_engine}.training_generator", "fit_generator"]
+    )
+
+    if training_v2_1:
+        training_v2_1.Loop.fit = new_v2
+        wandb.patched["keras"].append(
+            ["tensorflow.python.keras.engine.training_v2.Loop", "fit"]
+        )
+    elif training_v2_2:
+        training.Model.fit = new_v2
+        wandb.patched["keras"].append([f"{keras_engine}.training.Model", "fit"])
+
+
+def _array_has_dtype(array):
+    return hasattr(array, "dtype")
+
+
+def _update_if_numeric(metrics, key, values):
+    if not _array_has_dtype(values):
+        _warn_not_logging(key)
+        return
+
+    if not is_numeric_array(values):
+        _warn_not_logging_non_numeric(key)
+        return
+
+    metrics[key] = wandb.Histogram(values)
+
+
+def is_numeric_array(array):
+    return np.issubdtype(array.dtype, np.number)
+
+
+def _warn_not_logging_non_numeric(name):
+    wandb.termwarn(
+        f"Non-numeric values found in layer: {name}, not logging this layer",
+        repeat=False,
+    )
+
+
+def _warn_not_logging(name):
+    wandb.termwarn(
+        f"Layer {name} has undetermined datatype not logging this layer",
+        repeat=False,
+    )
+
+
+tf_logger = tf.get_logger()
+
+patch_tf_keras()
+
+
+### For gradient logging ###
+
+
+def _get_custom_optimizer_parent_class():
+    from wandb.util import parse_version
+
+    if parse_version(tf.__version__) >= parse_version("2.9.0"):
+        custom_optimizer_parent_class = tf.keras.optimizers.legacy.Optimizer
+    else:
+        custom_optimizer_parent_class = tf.keras.optimizers.Optimizer
+
+    return custom_optimizer_parent_class
+
+
+_custom_optimizer_parent_class = _get_custom_optimizer_parent_class()
+
+
+class _CustomOptimizer(_custom_optimizer_parent_class):
+    def __init__(self):
+        super().__init__(name="CustomOptimizer")
+        self._resource_apply_dense = tf.function(self._resource_apply_dense)
+        self._resource_apply_sparse = tf.function(self._resource_apply_sparse)
+
+    def _resource_apply_dense(self, grad, var):
+        var.assign(grad)
+
+    # this needs to be implemented to prevent a NotImplementedError when
+    # using Lookup layers.
+    def _resource_apply_sparse(self, grad, var, indices):
+        pass
+
+    def get_config(self):
+        return super().get_config()
+
+
+class _GradAccumulatorCallback(tf.keras.callbacks.Callback):
+    """Accumulates gradients during a fit() call when used in conjunction with the CustomOptimizer above."""
+
+    def set_model(self, model):
+        super().set_model(model)
+        self.og_weights = model.get_weights()
+        self.grads = [np.zeros(tuple(w.shape)) for w in model.trainable_weights]
+
+    def on_batch_end(self, batch, logs=None):
+        for g, w in zip(self.grads, self.model.trainable_weights):
+            g += w.numpy()
+        self.model.set_weights(self.og_weights)
+
+    def get_grads(self):
+        return [g.copy() for g in self.grads]
+
+
+###
+
+
+class WandbCallback(tf.keras.callbacks.Callback):
+    """`WandbCallback` automatically integrates keras with wandb.
+
+    Example:
+        ```python
+        model.fit(
+            X_train,
+            y_train,
+            validation_data=(X_test, y_test),
+            callbacks=[WandbCallback()],
+        )
+        ```
+
+    `WandbCallback` will automatically log history data from any
+    metrics collected by keras: loss and anything passed into `keras_model.compile()`.
+
+    `WandbCallback` will set summary metrics for the run associated with the "best" training
+    step, where "best" is defined by the `monitor` and `mode` attributes.  This defaults
+    to the epoch with the minimum `val_loss`. `WandbCallback` will by default save the model
+    associated with the best `epoch`.
+
+    `WandbCallback` can optionally log gradient and parameter histograms.
+
+    `WandbCallback` can optionally save training and validation data for wandb to visualize.
+
+    Args:
+        monitor: (str) name of metric to monitor.  Defaults to `val_loss`.
+        mode: (str) one of {`auto`, `min`, `max`}.
+            `min` - save model when monitor is minimized
+            `max` - save model when monitor is maximized
+            `auto` - try to guess when to save the model (default).
+        save_model:
+            True - save a model when monitor beats all previous epochs
+            False - don't save models
+        save_graph: (boolean) if True save model graph to wandb (default to True).
+        save_weights_only: (boolean) if True, then only the model's weights will be
+            saved (`model.save_weights(filepath)`), else the full model
+            is saved (`model.save(filepath)`).
+        log_weights: (boolean) if True save histograms of the model's layer's weights.
+        log_gradients: (boolean) if True log histograms of the training gradients
+        training_data: (tuple) Same format `(X,y)` as passed to `model.fit`.  This is needed
+            for calculating gradients - this is mandatory if `log_gradients` is `True`.
+        validation_data: (tuple) Same format `(X,y)` as passed to `model.fit`.  A set of data
+            for wandb to visualize.  If this is set, every epoch, wandb will
+            make a small number of predictions and save the results for later visualization. In case
+            you are working with image data, please also set `input_type` and `output_type` in order
+            to log correctly.
+        generator: (generator) a generator that returns validation data for wandb to visualize.  This
+            generator should return tuples `(X,y)`.  Either `validate_data` or generator should
+            be set for wandb to visualize specific data examples. In case you are working with image data,
+            please also set `input_type` and `output_type` in order to log correctly.
+        validation_steps: (int) if `validation_data` is a generator, how many
+            steps to run the generator for the full validation set.
+        labels: (list) If you are visualizing your data with wandb this list of labels
+            will convert numeric output to understandable string if you are building a
+            multiclass classifier.  If you are making a binary classifier you can pass in
+            a list of two labels ["label for false", "label for true"].  If `validate_data`
+            and generator are both false, this won't do anything.
+        predictions: (int) the number of predictions to make for visualization each epoch, max
+            is 100.
+        input_type: (string) type of the model input to help visualization. can be one of:
+            (`image`, `images`, `segmentation_mask`, `auto`).
+        output_type: (string) type of the model output to help visualization. can be one of:
+            (`image`, `images`, `segmentation_mask`, `label`).
+        log_evaluation: (boolean) if True, save a Table containing validation data and the
+            model's predictions at each epoch. See `validation_indexes`,
+            `validation_row_processor`, and `output_row_processor` for additional details.
+        class_colors: ([float, float, float]) if the input or output is a segmentation mask,
+            an array containing an rgb tuple (range 0-1) for each class.
+        log_batch_frequency: (integer) if None, callback will log every epoch.
+            If set to integer, callback will log training metrics every `log_batch_frequency`
+            batches.
+        log_best_prefix: (string) if None, no extra summary metrics will be saved.
+            If set to a string, the monitored metric and epoch will be prepended with this value
+            and stored as summary metrics.
+        validation_indexes: ([wandb.data_types._TableLinkMixin]) an ordered list of index keys to associate
+            with each validation example.  If log_evaluation is True and `validation_indexes` is provided,
+            then a Table of validation data will not be created and instead each prediction will
+            be associated with the row represented by the `TableLinkMixin`. The most common way to obtain
+            such keys are is use `Table.get_index()` which will return a list of row keys.
+        validation_row_processor: (Callable) a function to apply to the validation data, commonly used to visualize the data.
+            The function will receive an `ndx` (int) and a `row` (dict). If your model has a single input,
+            then `row["input"]` will be the input data for the row. Else, it will be keyed based on the name of the
+            input slot. If your fit function takes a single target, then `row["target"]` will be the target data for the row. Else,
+            it will be keyed based on the name of the output slots. For example, if your input data is a single ndarray,
+            but you wish to visualize the data as an Image, then you can provide `lambda ndx, row: {"img": wandb.Image(row["input"])}`
+            as the processor. Ignored if log_evaluation is False or `validation_indexes` are present.
+        output_row_processor: (Callable) same as `validation_row_processor`, but applied to the model's output. `row["output"]` will contain
+            the results of the model output.
+        infer_missing_processors: (bool) Determines if `validation_row_processor` and `output_row_processor`
+            should be inferred if missing. Defaults to True. If `labels` are provided, we will attempt to infer classification-type
+            processors where appropriate.
+        log_evaluation_frequency: (int) Determines the frequency which evaluation results will be logged. Default 0 (only at the end of training).
+            Set to 1 to log every epoch, 2 to log every other epoch, and so on. Has no effect when log_evaluation is False.
+        compute_flops: (bool) Compute the FLOPs of your Keras Sequential or Functional model in GigaFLOPs unit.
+    """
+
+    def __init__(
+        self,
+        monitor="val_loss",
+        verbose=0,
+        mode="auto",
+        save_weights_only=False,
+        log_weights=False,
+        log_gradients=False,
+        save_model=True,
+        training_data=None,
+        validation_data=None,
+        labels=None,
+        predictions=36,
+        generator=None,
+        input_type=None,
+        output_type=None,
+        log_evaluation=False,
+        validation_steps=None,
+        class_colors=None,
+        log_batch_frequency=None,
+        log_best_prefix="best_",
+        save_graph=True,
+        validation_indexes=None,
+        validation_row_processor=None,
+        prediction_row_processor=None,
+        infer_missing_processors=True,
+        log_evaluation_frequency=0,
+        compute_flops=False,
+        **kwargs,
+    ):
+        if wandb.run is None:
+            raise wandb.Error("You must call wandb.init() before WandbCallback()")
+
+        deprecate(
+            field_name=Deprecated.keras_callback,
+            warning_message=(
+                "WandbCallback is deprecated and will be removed in a future release. "
+                "Please use the WandbMetricsLogger, WandbModelCheckpoint, and WandbEvalCallback "
+                "callbacks instead. "
+                "See https://docs.wandb.ai/guides/integrations/keras for more information."
+            ),
+        )
+
+        with wandb.wandb_lib.telemetry.context(run=wandb.run) as tel:
+            tel.feature.keras = True
+        self.validation_data = None
+        # This is kept around for legacy reasons
+        if validation_data is not None:
+            if is_generator_like(validation_data):
+                generator = validation_data
+            else:
+                self.validation_data = validation_data
+        if labels is None:
+            labels = []
+        self.labels = labels
+        self.predictions = min(predictions, 100)
+
+        self.monitor = monitor
+        self.verbose = verbose
+        self.save_weights_only = save_weights_only
+        self.save_graph = save_graph
+
+        wandb.save("model-best.h5")
+        self.filepath = os.path.join(wandb.run.dir, "model-best.h5")
+        self.save_model = save_model
+        if save_model:
+            deprecate(
+                field_name=Deprecated.keras_callback__save_model,
+                warning_message=(
+                    "The save_model argument by default saves the model in the HDF5 format that cannot save "
+                    "custom objects like subclassed models and custom layers. This behavior will be deprecated "
+                    "in a future release in favor of the SavedModel format. Meanwhile, the HDF5 model is saved "
+                    "as W&B files and the SavedModel as W&B Artifacts."
+                ),
+            )
+
+        self.save_model_as_artifact = True
+        self.log_weights = log_weights
+        self.log_gradients = log_gradients
+        self.training_data = training_data
+        self.generator = generator
+        self._graph_rendered = False
+
+        data_type = kwargs.get("data_type", None)
+        if data_type is not None:
+            deprecate(
+                field_name=Deprecated.keras_callback__data_type,
+                warning_message=(
+                    "The data_type argument of wandb.keras.WandbCallback is deprecated "
+                    "and will be removed in a future release. Please use input_type instead.\n"
+                    "Setting input_type = data_type."
+                ),
+            )
+            input_type = data_type
+        self.input_type = input_type
+        self.output_type = output_type
+        self.log_evaluation = log_evaluation
+        self.validation_steps = validation_steps
+        self.class_colors = np.array(class_colors) if class_colors is not None else None
+        self.log_batch_frequency = log_batch_frequency
+        self.log_best_prefix = log_best_prefix
+        self.compute_flops = compute_flops
+
+        self._prediction_batch_size = None
+
+        if self.log_gradients:
+            if int(tf.__version__.split(".")[0]) < 2:
+                raise Exception("Gradient logging requires tensorflow 2.0 or higher.")
+            if self.training_data is None:
+                raise ValueError(
+                    "training_data argument is required for gradient logging."
+                )
+            if isinstance(self.training_data, (list, tuple)):
+                if len(self.training_data) != 2:
+                    raise ValueError("training data must be a tuple of length two")
+                self._training_data_x, self._training_data_y = self.training_data
+            else:
+                self._training_data_x = (
+                    self.training_data
+                )  # generator, tf.data.Dataset etc
+                self._training_data_y = None
+
+        # From Keras
+        if mode not in ["auto", "min", "max"]:
+            wandb.termwarn(
+                f"WandbCallback mode {mode} is unknown, fallback to auto mode."
+            )
+            mode = "auto"
+
+        if mode == "min":
+            self.monitor_op = operator.lt
+            self.best = float("inf")
+        elif mode == "max":
+            self.monitor_op = operator.gt
+            self.best = float("-inf")
+        else:
+            if "acc" in self.monitor or self.monitor.startswith("fmeasure"):
+                self.monitor_op = operator.gt
+                self.best = float("-inf")
+            else:
+                self.monitor_op = operator.lt
+                self.best = float("inf")
+        # Get the previous best metric for resumed runs
+        previous_best = wandb.run.summary.get(f"{self.log_best_prefix}{self.monitor}")
+        if previous_best is not None:
+            self.best = previous_best
+
+        self._validation_data_logger = None
+        self._validation_indexes = validation_indexes
+        self._validation_row_processor = validation_row_processor
+        self._prediction_row_processor = prediction_row_processor
+        self._infer_missing_processors = infer_missing_processors
+        self._log_evaluation_frequency = log_evaluation_frequency
+        self._model_trained_since_last_eval = False
+
+    def _build_grad_accumulator_model(self):
+        inputs = self.model.inputs
+        outputs = self.model(inputs)
+        grad_acc_model = tf.keras.models.Model(inputs, outputs)
+        grad_acc_model.compile(loss=self.model.loss, optimizer=_CustomOptimizer())
+
+        # make sure magic doesn't think this is a user model
+        grad_acc_model._wandb_internal_model = True
+
+        self._grad_accumulator_model = grad_acc_model
+        self._grad_accumulator_callback = _GradAccumulatorCallback()
+
+    def _implements_train_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def _implements_test_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def _implements_predict_batch_hooks(self):
+        return self.log_batch_frequency is not None
+
+    def set_params(self, params):
+        self.params = params
+
+    def set_model(self, model):
+        super().set_model(model)
+        if self.input_type == "auto" and len(model.inputs) == 1:
+            self.input_type = wandb.util.guess_data_type(
+                model.inputs[0].shape, risky=True
+            )
+        if self.input_type and self.output_type is None and len(model.outputs) == 1:
+            self.output_type = wandb.util.guess_data_type(model.outputs[0].shape)
+        if self.log_gradients:
+            self._build_grad_accumulator_model()
+
+    def _attempt_evaluation_log(self, commit=True):
+        if self.log_evaluation and self._validation_data_logger:
+            try:
+                if not self.model:
+                    wandb.termwarn("WandbCallback unable to read model from trainer")
+                else:
+                    self._validation_data_logger.log_predictions(
+                        predictions=self._validation_data_logger.make_predictions(
+                            self.model.predict
+                        ),
+                        commit=commit,
+                    )
+                    self._model_trained_since_last_eval = False
+            except Exception as e:
+                wandb.termwarn("Error during prediction logging for epoch: " + str(e))
+
+    def on_epoch_end(self, epoch, logs=None):
+        if logs is None:
+            logs = {}
+        if self.log_weights:
+            wandb.log(self._log_weights(), commit=False)
+
+        if self.log_gradients:
+            wandb.log(self._log_gradients(), commit=False)
+
+        if self.input_type in (
+            "image",
+            "images",
+            "segmentation_mask",
+        ) or self.output_type in ("image", "images", "segmentation_mask"):
+            if self.generator:
+                self.validation_data = next(self.generator)
+            if self.validation_data is None:
+                wandb.termwarn(
+                    "No validation_data set, pass a generator to the callback."
+                )
+            elif self.validation_data and len(self.validation_data) > 0:
+                wandb.log(
+                    {"examples": self._log_images(num_images=self.predictions)},
+                    commit=False,
+                )
+
+        if (
+            self._log_evaluation_frequency > 0
+            and epoch % self._log_evaluation_frequency == 0
+        ):
+            self._attempt_evaluation_log(commit=False)
+
+        wandb.log({"epoch": epoch}, commit=False)
+        wandb.log(logs, commit=True)
+
+        self.current = logs.get(self.monitor)
+        if self.current and self.monitor_op(self.current, self.best):
+            if self.log_best_prefix:
+                wandb.run.summary[f"{self.log_best_prefix}{self.monitor}"] = (
+                    self.current
+                )
+                wandb.run.summary["{}{}".format(self.log_best_prefix, "epoch")] = epoch
+                if self.verbose and not self.save_model:
+                    wandb.termlog(
+                        f"Epoch {epoch:05d}: {self.monitor} improved from {self.best:.5f} to {self.current:.5f}"
+                    )
+            if self.save_model:
+                self._save_model(epoch)
+
+            if self.save_model and self.save_model_as_artifact:
+                self._save_model_as_artifact(epoch)
+
+            self.best = self.current
+
+    # This is what keras used pre tensorflow.keras
+    def on_batch_begin(self, batch, logs=None):
+        pass
+
+    # This is what keras used pre tensorflow.keras
+    def on_batch_end(self, batch, logs=None):
+        if self.save_graph and not self._graph_rendered:
+            # Couldn't do this in train_begin because keras may still not be built
+            wandb.run.summary["graph"] = wandb.Graph.from_keras(self.model)
+            self._graph_rendered = True
+
+        if self.log_batch_frequency and batch % self.log_batch_frequency == 0:
+            wandb.log(logs, commit=True)
+
+    def on_train_batch_begin(self, batch, logs=None):
+        self._model_trained_since_last_eval = True
+
+    def on_train_batch_end(self, batch, logs=None):
+        if self.save_graph and not self._graph_rendered:
+            # Couldn't do this in train_begin because keras may still not be built
+            wandb.run.summary["graph"] = wandb.Graph.from_keras(self.model)
+            self._graph_rendered = True
+
+        if self.log_batch_frequency and batch % self.log_batch_frequency == 0:
+            wandb.log(logs, commit=True)
+
+    def on_test_begin(self, logs=None):
+        pass
+
+    def on_test_end(self, logs=None):
+        pass
+
+    def on_test_batch_begin(self, batch, logs=None):
+        pass
+
+    def on_test_batch_end(self, batch, logs=None):
+        pass
+
+    def on_train_begin(self, logs=None):
+        if self.log_evaluation:
+            try:
+                validation_data = None
+                if self.validation_data:
+                    validation_data = self.validation_data
+                elif self.generator:
+                    if not self.validation_steps:
+                        wandb.termwarn(
+                            "WandbCallback is unable to log validation data. "
+                            "When using a generator for validation_data, you must pass validation_steps"
+                        )
+                    else:
+                        x = None
+                        y_true = None
+                        for _ in range(self.validation_steps):
+                            bx, by_true = next(self.generator)
+                            if x is None:
+                                x, y_true = bx, by_true
+                            else:
+                                x, y_true = (
+                                    np.append(x, bx, axis=0),
+                                    np.append(y_true, by_true, axis=0),
+                                )
+                        validation_data = (x, y_true)
+                else:
+                    wandb.termwarn(
+                        "WandbCallback is unable to read validation_data from trainer "
+                        "and therefore cannot log validation data. Ensure Keras is properly "
+                        "patched by calling `from wandb.keras import WandbCallback` at the top of your script."
+                    )
+                if validation_data:
+                    self._validation_data_logger = ValidationDataLogger(
+                        inputs=validation_data[0],
+                        targets=validation_data[1],
+                        indexes=self._validation_indexes,
+                        validation_row_processor=self._validation_row_processor,
+                        prediction_row_processor=self._prediction_row_processor,
+                        class_labels=self.labels,
+                        infer_missing_processors=self._infer_missing_processors,
+                    )
+            except Exception as e:
+                wandb.termwarn(
+                    "Error initializing ValidationDataLogger in WandbCallback. "
+                    f"Skipping logging validation data. Error: {str(e)}"
+                )
+
+        if self.compute_flops and _can_compute_flops():
+            try:
+                wandb.summary["GFLOPs"] = self.get_flops()
+            except Exception as e:
+                wandb.termwarn("Unable to compute FLOPs for this model.")
+                logger.exception(e)
+
+    def on_train_end(self, logs=None):
+        if self._model_trained_since_last_eval:
+            self._attempt_evaluation_log()
+
+    def on_predict_begin(self, logs=None):
+        pass
+
+    def on_predict_end(self, logs=None):
+        pass
+
+    def on_predict_batch_begin(self, batch, logs=None):
+        pass
+
+    def on_predict_batch_end(self, batch, logs=None):
+        pass
+
+    def _logits_to_captions(self, logits):
+        if logits[0].shape[-1] == 1:
+            # Scalar output from the model
+            # TODO: handle validation_y
+            if len(self.labels) == 2:
+                # User has named true and false
+                captions = [
+                    self.labels[1] if logits[0] > 0.5 else self.labels[0]
+                    for logit in logits
+                ]
+            else:
+                if len(self.labels) != 0:
+                    wandb.termwarn(
+                        "keras model is producing a single output, "
+                        'so labels should be a length two array: ["False label", "True label"].'
+                    )
+                captions = [logit[0] for logit in logits]
+        else:
+            # Vector output from the model
+            # TODO: handle validation_y
+            labels = np.argmax(np.stack(logits), axis=1)
+
+            if len(self.labels) > 0:
+                # User has named the categories in self.labels
+                captions = []
+                for label in labels:
+                    try:
+                        captions.append(self.labels[label])
+                    except IndexError:
+                        captions.append(label)
+            else:
+                captions = labels
+        return captions
+
+    def _masks_to_pixels(self, masks):
+        # if its a binary mask, just return it as grayscale instead of picking the argmax
+        if len(masks[0].shape) == 2 or masks[0].shape[-1] == 1:
+            return masks
+        class_colors = (
+            self.class_colors
+            if self.class_colors is not None
+            else np.array(wandb.util.class_colors(masks[0].shape[2]))
+        )
+        imgs = class_colors[np.argmax(masks, axis=-1)]
+        return imgs
+
+    def _log_images(self, num_images=36):
+        validation_X = self.validation_data[0]  # noqa: N806
+        validation_y = self.validation_data[1]
+
+        validation_length = len(validation_X)
+
+        if validation_length > num_images:
+            # pick some data at random
+            indices = np.random.choice(validation_length, num_images, replace=False)
+        else:
+            indices = range(validation_length)
+
+        test_data = []
+        test_output = []
+        for i in indices:
+            test_example = validation_X[i]
+            test_data.append(test_example)
+            test_output.append(validation_y[i])
+
+        if self.model.stateful:
+            predictions = self.model.predict(np.stack(test_data), batch_size=1)
+            self.model.reset_states()
+        else:
+            predictions = self.model.predict(
+                np.stack(test_data), batch_size=self._prediction_batch_size
+            )
+            if len(predictions) != len(test_data):
+                self._prediction_batch_size = 1
+                predictions = self.model.predict(
+                    np.stack(test_data), batch_size=self._prediction_batch_size
+                )
+
+        if self.input_type == "label":
+            if self.output_type in ("image", "images", "segmentation_mask"):
+                captions = self._logits_to_captions(test_data)
+                output_image_data = (
+                    self._masks_to_pixels(predictions)
+                    if self.output_type == "segmentation_mask"
+                    else predictions
+                )
+                reference_image_data = (
+                    self._masks_to_pixels(test_output)
+                    if self.output_type == "segmentation_mask"
+                    else test_output
+                )
+                output_images = [
+                    wandb.Image(data, caption=captions[i], grouping=2)
+                    for i, data in enumerate(output_image_data)
+                ]
+                reference_images = [
+                    wandb.Image(data, caption=captions[i])
+                    for i, data in enumerate(reference_image_data)
+                ]
+                return list(chain.from_iterable(zip(output_images, reference_images)))
+        elif self.input_type in ("image", "images", "segmentation_mask"):
+            input_image_data = (
+                self._masks_to_pixels(test_data)
+                if self.input_type == "segmentation_mask"
+                else test_data
+            )
+            if self.output_type == "label":
+                # we just use the predicted label as the caption for now
+                captions = self._logits_to_captions(predictions)
+                return [
+                    wandb.Image(data, caption=captions[i])
+                    for i, data in enumerate(test_data)
+                ]
+            elif self.output_type in ("image", "images", "segmentation_mask"):
+                output_image_data = (
+                    self._masks_to_pixels(predictions)
+                    if self.output_type == "segmentation_mask"
+                    else predictions
+                )
+                reference_image_data = (
+                    self._masks_to_pixels(test_output)
+                    if self.output_type == "segmentation_mask"
+                    else test_output
+                )
+                input_images = [
+                    wandb.Image(data, grouping=3)
+                    for i, data in enumerate(input_image_data)
+                ]
+                output_images = [
+                    wandb.Image(data) for i, data in enumerate(output_image_data)
+                ]
+                reference_images = [
+                    wandb.Image(data) for i, data in enumerate(reference_image_data)
+                ]
+                return list(
+                    chain.from_iterable(
+                        zip(input_images, output_images, reference_images)
+                    )
+                )
+            else:
+                # unknown output, just log the input images
+                return [wandb.Image(img) for img in test_data]
+        elif self.output_type in ("image", "images", "segmentation_mask"):
+            # unknown input, just log the predicted and reference outputs without captions
+            output_image_data = (
+                self._masks_to_pixels(predictions)
+                if self.output_type == "segmentation_mask"
+                else predictions
+            )
+            reference_image_data = (
+                self._masks_to_pixels(test_output)
+                if self.output_type == "segmentation_mask"
+                else test_output
+            )
+            output_images = [
+                wandb.Image(data, grouping=2)
+                for i, data in enumerate(output_image_data)
+            ]
+            reference_images = [
+                wandb.Image(data) for i, data in enumerate(reference_image_data)
+            ]
+            return list(chain.from_iterable(zip(output_images, reference_images)))
+
+    def _log_weights(self):
+        metrics = {}
+        for layer in self.model.layers:
+            weights = layer.get_weights()
+            if len(weights) == 1:
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".weights", weights[0]
+                )
+            elif len(weights) == 2:
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".weights", weights[0]
+                )
+                _update_if_numeric(
+                    metrics, "parameters/" + layer.name + ".bias", weights[1]
+                )
+        return metrics
+
+    def _log_gradients(self):
+        # Suppress callback warnings grad accumulator
+        og_level = tf_logger.level
+        tf_logger.setLevel("ERROR")
+
+        self._grad_accumulator_model.fit(
+            self._training_data_x,
+            self._training_data_y,
+            verbose=0,
+            callbacks=[self._grad_accumulator_callback],
+        )
+        tf_logger.setLevel(og_level)
+        weights = self.model.trainable_weights
+        grads = self._grad_accumulator_callback.grads
+        metrics = {}
+        for weight, grad in zip(weights, grads):
+            metrics["gradients/" + weight.name.split(":")[0] + ".gradient"] = (
+                wandb.Histogram(grad)
+            )
+        return metrics
+
+    def _log_dataframe(self):
+        x, y_true, y_pred = None, None, None
+
+        if self.validation_data:
+            x, y_true = self.validation_data[0], self.validation_data[1]
+            y_pred = self.model.predict(x)
+        elif self.generator:
+            if not self.validation_steps:
+                wandb.termwarn(
+                    "when using a generator for validation data with dataframes, "
+                    "you must pass validation_steps. skipping"
+                )
+                return None
+
+            for _ in range(self.validation_steps):
+                bx, by_true = next(self.generator)
+                by_pred = self.model.predict(bx)
+                if x is None:
+                    x, y_true, y_pred = bx, by_true, by_pred
+                else:
+                    x, y_true, y_pred = (
+                        np.append(x, bx, axis=0),
+                        np.append(y_true, by_true, axis=0),
+                        np.append(y_pred, by_pred, axis=0),
+                    )
+
+        if self.input_type in ("image", "images") and self.output_type == "label":
+            return wandb.image_categorizer_dataframe(
+                x=x, y_true=y_true, y_pred=y_pred, labels=self.labels
+            )
+        elif (
+            self.input_type in ("image", "images")
+            and self.output_type == "segmentation_mask"
+        ):
+            return wandb.image_segmentation_dataframe(
+                x=x,
+                y_true=y_true,
+                y_pred=y_pred,
+                labels=self.labels,
+                class_colors=self.class_colors,
+            )
+        else:
+            wandb.termwarn(
+                f"unknown dataframe type for input_type={self.input_type} and output_type={self.output_type}"
+            )
+            return None
+
+    def _save_model(self, epoch):
+        if wandb.run.disabled:
+            return
+        if self.verbose > 0:
+            wandb.termlog(
+                f"Epoch {epoch:05d}: {self.monitor} improved from {self.best:.5f} to {self.current:.5f}, "
+                f"saving model to {self.filepath}"
+            )
+
+        try:
+            if self.save_weights_only:
+                self.model.save_weights(self.filepath, overwrite=True)
+            else:
+                self.model.save(self.filepath, overwrite=True)
+        # Was getting `RuntimeError: Unable to create link` in TF 1.13.1
+        # also saw `TypeError: can't pickle _thread.RLock objects`
+        except (ImportError, RuntimeError, TypeError, AttributeError) as e:
+            wandb.termerror(
+                "Can't save model in the h5py format. The model will be saved as "
+                "as an W&B Artifact in the 'tf' format."
+            )
+            logger.exception(e)
+
+    def _save_model_as_artifact(self, epoch):
+        if wandb.run.disabled:
+            return
+
+        # Save the model in the SavedModel format.
+        # TODO: Replace this manual artifact creation with the `log_model` method
+        # after `log_model` is released from beta.
+        self.model.save(self.filepath[:-3], overwrite=True, save_format="tf")
+
+        # Log the model as artifact.
+        name = wandb.util.make_artifact_name_safe(f"model-{wandb.run.name}")
+        model_artifact = wandb.Artifact(name, type="model")
+        model_artifact.add_dir(self.filepath[:-3])
+        wandb.run.log_artifact(model_artifact, aliases=["latest", f"epoch_{epoch}"])
+
+        # Remove the SavedModel from wandb dir as we don't want to log it to save memory.
+        shutil.rmtree(self.filepath[:-3])
+
+    def get_flops(self) -> float:
+        """Calculate FLOPS [GFLOPs] for a tf.keras.Model or tf.keras.Sequential model in inference mode.
+
+        It uses tf.compat.v1.profiler under the hood.
+        """
+        if not hasattr(self, "model"):
+            raise wandb.Error("self.model must be set before using this method.")
+
+        if not isinstance(
+            self.model, (tf.keras.models.Sequential, tf.keras.models.Model)
+        ):
+            raise ValueError(
+                "Calculating FLOPS is only supported for "
+                "`tf.keras.Model` and `tf.keras.Sequential` instances."
+            )
+
+        from tensorflow.python.framework.convert_to_constants import (
+            convert_variables_to_constants_v2_as_graph,
+        )
+
+        # Compute FLOPs for one sample
+        batch_size = 1
+        inputs = [
+            tf.TensorSpec([batch_size] + inp.shape[1:], inp.dtype)
+            for inp in self.model.inputs
+        ]
+
+        # convert tf.keras model into frozen graph to count FLOPs about operations used at inference
+        real_model = tf.function(self.model).get_concrete_function(inputs)
+        frozen_func, _ = convert_variables_to_constants_v2_as_graph(real_model)
+
+        # Calculate FLOPs with tf.profiler
+        run_meta = tf.compat.v1.RunMetadata()
+        opts = (
+            tf.compat.v1.profiler.ProfileOptionBuilder(
+                tf.compat.v1.profiler.ProfileOptionBuilder().float_operation()
+            )
+            .with_empty_output()
+            .build()
+        )
+
+        flops = tf.compat.v1.profiler.profile(
+            graph=frozen_func.graph, run_meta=run_meta, cmd="scope", options=opts
+        )
+
+        # convert to GFLOPs
+        return (flops.total_float_ops / 1e9) / 2

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/sacred/__init__.py

@@ -0,0 +1,117 @@
+import warnings
+
+import numpy
+from sacred.dependencies import get_digest
+from sacred.observers import RunObserver
+
+import wandb
+
+
+class WandbObserver(RunObserver):
+    """Log sacred experiment data to W&B.
+
+    Args:
+        Accepts all the arguments accepted by wandb.init().
+
+        name — A display name for this run, which shows up in the UI and is editable, doesn't have to be unique
+        notes — A multiline string description associated with the run
+        config — a dictionary-like object to set as initial config
+        project — the name of the project to which this run will belong
+        tags — a list of strings to associate with this run as tags
+        dir — the path to a directory where artifacts will be written (default: ./wandb)
+        entity — the team posting this run (default: your username or your default team)
+        job_type — the type of job you are logging, e.g. eval, worker, ps (default: training)
+        save_code — save the main python or notebook file to wandb to enable diffing (default: editable from your settings page)
+        group — a string by which to group other runs; see Grouping
+        reinit — whether to allow multiple calls to wandb.init in the same process (default: False)
+        id — A unique ID for this run primarily used for Resuming. It must be globally unique, and if you delete a run you can't reuse the ID. Use the name field for a descriptive, useful name for the run. The ID cannot contain special characters.
+        resume — if set to True, the run auto resumes; can also be a unique string for manual resuming; see Resuming (default: False)
+        anonymous — can be "allow", "never", or "must". This enables or explicitly disables anonymous logging. (default: never)
+        force — whether to force a user to be logged into wandb when running a script (default: False)
+        magic — (bool, dict, or str, optional): magic configuration as bool, dict, json string, yaml filename. If set to True will attempt to auto-instrument your script. (default: None)
+        sync_tensorboard — A boolean indicating whether or not copy all TensorBoard logs wandb; see Tensorboard (default: False)
+        monitor_gym — A boolean indicating whether or not to log videos generated by OpenAI Gym; see Ray Tune (default: False)
+        allow_val_change — whether to allow wandb.config values to change, by default we throw an exception if config values are overwritten. (default: False)
+
+    Examples:
+        Create sacred experiment::
+        from wandb.sacred import WandbObserver
+        ex.observers.append(WandbObserver(project='sacred_test',
+                                                name='test1'))
+        @ex.config
+        def cfg():
+            C = 1.0
+            gamma = 0.7
+        @ex.automain
+        def run(C, gamma, _run):
+            iris = datasets.load_iris()
+            per = permutation(iris.target.size)
+            iris.data = iris.data[per]
+            iris.target = iris.target[per]
+            clf = svm.SVC(C, 'rbf', gamma=gamma)
+            clf.fit(iris.data[:90],
+                    iris.target[:90])
+            return clf.score(iris.data[90:],
+                                iris.target[90:])
+    """
+
+    def __init__(self, **kwargs):
+        self.run = wandb.init(**kwargs)
+        self.resources = {}
+
+    def started_event(
+        self, ex_info, command, host_info, start_time, config, meta_info, _id
+    ):
+        # TODO: add the source code file
+        # TODO: add dependencies and metadata.
+        self.__update_config(config)
+
+    def completed_event(self, stop_time, result):
+        if result:
+            if not isinstance(result, tuple):
+                result = (
+                    result,
+                )  # transform single result to tuple so that both single & multiple results use same code
+
+            for i, r in enumerate(result):
+                if isinstance(r, float) or isinstance(r, int):
+                    wandb.log({f"result_{i}": float(r)})
+                elif isinstance(r, dict):
+                    wandb.log(r)
+                elif isinstance(r, object):
+                    artifact = wandb.Artifact(f"result_{i}.pkl", type="result")
+                    artifact.add_file(r)
+                    self.run.log_artifact(artifact)
+                elif isinstance(r, numpy.ndarray):
+                    wandb.log({f"result_{i}": wandb.Image(r)})
+                else:
+                    warnings.warn(
+                        f"logging results does not support type '{type(r)}' results. Ignoring this result",
+                        stacklevel=2,
+                    )
+
+    def artifact_event(self, name, filename, metadata=None, content_type=None):
+        if content_type is None:
+            content_type = "file"
+        artifact = wandb.Artifact(name, type=content_type)
+        artifact.add_file(filename)
+        self.run.log_artifact(artifact)
+
+    def resource_event(self, filename):
+        """TODO: Maintain resources list."""
+        if filename not in self.resources:
+            md5 = get_digest(filename)
+            self.resources[filename] = md5
+
+    def log_metrics(self, metrics_by_name, info):
+        for metric_name, metric_ptr in metrics_by_name.items():
+            for _step, value in zip(metric_ptr["steps"], metric_ptr["values"]):
+                if isinstance(value, numpy.ndarray):
+                    wandb.log({metric_name: wandb.Image(value)})
+                else:
+                    wandb.log({metric_name: value})
+
+    def __update_config(self, config):
+        for k, v in config.items():
+            self.run.config[k] = v
+        self.run.config["resources"] = []

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/sb3/__init__.py

@@ -0,0 +1,3 @@
+from .sb3 import WandbCallback
+
+__all__ = ["WandbCallback"]

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/sb3/sb3.py

@@ -0,0 +1,147 @@
+"""W&B callback for sb3.
+
+Really simple callback to get logging for each tree
+
+Example usage:
+
+```python
+import gym
+from stable_baselines3 import PPO
+from stable_baselines3.common.monitor import Monitor
+from stable_baselines3.common.vec_env import DummyVecEnv, VecVideoRecorder
+import wandb
+from wandb.integration.sb3 import WandbCallback
+
+
+config = {
+    "policy_type": "MlpPolicy",
+    "total_timesteps": 25000,
+    "env_name": "CartPole-v1",
+}
+run = wandb.init(
+    project="sb3",
+    config=config,
+    sync_tensorboard=True,  # auto-upload sb3's tensorboard metrics
+    monitor_gym=True,  # auto-upload the videos of agents playing the game
+    save_code=True,  # optional
+)
+
+
+def make_env():
+    env = gym.make(config["env_name"])
+    env = Monitor(env)  # record stats such as returns
+    return env
+
+
+env = DummyVecEnv([make_env])
+env = VecVideoRecorder(
+    env, "videos", record_video_trigger=lambda x: x % 2000 == 0, video_length=200
+)
+model = PPO(config["policy_type"], env, verbose=1, tensorboard_log=f"runs")
+model.learn(
+    total_timesteps=config["total_timesteps"],
+    callback=WandbCallback(
+        model_save_path=f"models/{run.id}",
+        gradient_save_freq=100,
+        log="all",
+    ),
+)
+```
+"""
+
+import logging
+import os
+from typing import Literal, Optional
+
+from stable_baselines3.common.callbacks import BaseCallback  # type: ignore
+
+import wandb
+from wandb.sdk.lib import telemetry as wb_telemetry
+
+logger = logging.getLogger(__name__)
+
+
+class WandbCallback(BaseCallback):
+    """Callback for logging experiments to Weights and Biases.
+
+    Log SB3 experiments to Weights and Biases
+        - Added model tracking and uploading
+        - Added complete hyperparameters recording
+        - Added gradient logging
+        - Note that `wandb.init(...)` must be called before the WandbCallback can be used.
+
+    Args:
+        verbose: The verbosity of sb3 output
+        model_save_path: Path to the folder where the model will be saved, The default value is `None` so the model is not logged
+        model_save_freq: Frequency to save the model
+        gradient_save_freq: Frequency to log gradient. The default value is 0 so the gradients are not logged
+        log: What to log. One of "gradients", "parameters", or "all".
+    """
+
+    def __init__(
+        self,
+        verbose: int = 0,
+        model_save_path: Optional[str] = None,
+        model_save_freq: int = 0,
+        gradient_save_freq: int = 0,
+        log: Optional[Literal["gradients", "parameters", "all"]] = "all",
+    ) -> None:
+        super().__init__(verbose)
+        if wandb.run is None:
+            raise wandb.Error("You must call wandb.init() before WandbCallback()")
+        with wb_telemetry.context() as tel:
+            tel.feature.sb3 = True
+        self.model_save_freq = model_save_freq
+        self.model_save_path = model_save_path
+        self.gradient_save_freq = gradient_save_freq
+        if log not in ["gradients", "parameters", "all", None]:
+            wandb.termwarn(
+                "`log` must be one of `None`, 'gradients', 'parameters', or 'all', "
+                "falling back to 'all'"
+            )
+            log = "all"
+        self.log = log
+        # Create folder if needed
+        if self.model_save_path is not None:
+            os.makedirs(self.model_save_path, exist_ok=True)
+            self.path = os.path.join(self.model_save_path, "model.zip")
+        else:
+            assert (
+                self.model_save_freq == 0
+            ), "to use the `model_save_freq` you have to set the `model_save_path` parameter"
+
+    def _init_callback(self) -> None:
+        d = {}
+        if "algo" not in d:
+            d["algo"] = type(self.model).__name__
+        for key in self.model.__dict__:
+            if key in wandb.config:
+                continue
+            if type(self.model.__dict__[key]) in [float, int, str]:
+                d[key] = self.model.__dict__[key]
+            else:
+                d[key] = str(self.model.__dict__[key])
+        if self.gradient_save_freq > 0:
+            wandb.watch(
+                self.model.policy,
+                log_freq=self.gradient_save_freq,
+                log=self.log,
+            )
+        wandb.config.setdefaults(d)
+
+    def _on_step(self) -> bool:
+        if self.model_save_freq > 0:
+            if self.model_save_path is not None:
+                if self.n_calls % self.model_save_freq == 0:
+                    self.save_model()
+        return True
+
+    def _on_training_end(self) -> None:
+        if self.model_save_path is not None:
+            self.save_model()
+
+    def save_model(self) -> None:
+        self.model.save(self.path)
+        wandb.save(self.path, base_path=self.model_save_path)
+        if self.verbose > 1:
+            logger.info(f"Saving model checkpoint to {self.path}")

evalkit_cambrian/lib/python3.10/site-packages/wandb/integration/yolov8/yolov8.py

@@ -0,0 +1,284 @@
+from typing import Any, Callable, Dict, List, Optional
+
+from ultralytics.yolo.engine.model import YOLO
+from ultralytics.yolo.engine.trainer import BaseTrainer
+
+try:
+    from ultralytics.yolo.utils import RANK
+    from ultralytics.yolo.utils.torch_utils import get_flops, get_num_params
+except ModuleNotFoundError:
+    from ultralytics.utils import RANK
+    from ultralytics.utils.torch_utils import get_flops, get_num_params
+from ultralytics.yolo.v8.classify.train import ClassificationTrainer
+
+import wandb
+from wandb.sdk.lib import telemetry
+
+
+class WandbCallback:
+    """An internal YOLO model wrapper that tracks metrics, and logs models to Weights & Biases.
+
+    Usage:
+    ```python
+    from wandb.integration.yolov8.yolov8 import WandbCallback
+
+    model = YOLO("yolov8n.pt")
+    wandb_logger = WandbCallback(
+        model,
+    )
+    for event, callback_fn in wandb_logger.callbacks.items():
+        model.add_callback(event, callback_fn)
+    ```
+    """
+
+    def __init__(
+        self,
+        yolo: YOLO,
+        run_name: Optional[str] = None,
+        project: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        resume: Optional[str] = None,
+        **kwargs: Optional[Any],
+    ) -> None:
+        """A utility class to manage wandb run and various callbacks for the ultralytics YOLOv8 framework.
+
+        Args:
+            yolo: A YOLOv8 model that's inherited from `:class:ultralytics.yolo.engine.model.YOLO`
+            run_name, str: The name of the Weights & Biases run, defaults to an auto generated run_name if `trainer.args.name` is not defined.
+            project, str: The name of the Weights & Biases project, defaults to `"YOLOv8"` if `trainer.args.project` is not defined.
+            tags, List[str]: A list of tags to be added to the Weights & Biases run, defaults to `["YOLOv8"]`.
+            resume, str: Whether to resume a previous run on Weights & Biases, defaults to `None`.
+            **kwargs: Additional arguments to be passed to `wandb.init()`.
+        """
+        self.yolo = yolo
+        self.run_name = run_name
+        self.project = project
+        self.tags = tags
+        self.resume = resume
+        self.kwargs = kwargs
+
+    def on_pretrain_routine_start(self, trainer: BaseTrainer) -> None:
+        """Starts a new wandb run to track the training process and log to Weights & Biases.
+
+        Args:
+            trainer: A task trainer that's inherited from `:class:ultralytics.yolo.engine.trainer.BaseTrainer`
+                    that contains the model training and optimization routine.
+        """
+        if wandb.run is None:
+            self.run = wandb.init(
+                name=self.run_name if self.run_name else trainer.args.name,
+                project=self.project
+                if self.project
+                else trainer.args.project or "YOLOv8",
+                tags=self.tags if self.tags else ["YOLOv8"],
+                config=vars(trainer.args),
+                resume=self.resume if self.resume else None,
+                **self.kwargs,
+            )
+        else:
+            self.run = wandb.run
+        assert self.run is not None
+        self.run.define_metric("epoch", hidden=True)
+        self.run.define_metric(
+            "train/*", step_metric="epoch", step_sync=True, summary="min"
+        )
+
+        self.run.define_metric(
+            "val/*", step_metric="epoch", step_sync=True, summary="min"
+        )
+
+        self.run.define_metric(
+            "metrics/*", step_metric="epoch", step_sync=True, summary="max"
+        )
+        self.run.define_metric(
+            "lr/*", step_metric="epoch", step_sync=True, summary="last"
+        )
+
+        with telemetry.context(run=wandb.run) as tel:
+            tel.feature.ultralytics_yolov8 = True
+
+    def on_pretrain_routine_end(self, trainer: BaseTrainer) -> None:
+        assert self.run is not None
+        self.run.summary.update(
+            {
+                "model/parameters": get_num_params(trainer.model),
+                "model/GFLOPs": round(get_flops(trainer.model), 3),
+            }
+        )
+
+    def on_train_epoch_start(self, trainer: BaseTrainer) -> None:
+        """On train epoch start we only log epoch number to the Weights & Biases run."""
+        # We log the epoch number here to commit the previous step,
+        assert self.run is not None
+        self.run.log({"epoch": trainer.epoch + 1})
+
+    def on_train_epoch_end(self, trainer: BaseTrainer) -> None:
+        """On train epoch end we log all the metrics to the Weights & Biases run."""
+        assert self.run is not None
+        self.run.log(
+            {
+                **trainer.metrics,
+                **trainer.label_loss_items(trainer.tloss, prefix="train"),
+                **trainer.lr,
+            },
+        )
+        # Currently only the detection and segmentation trainers save images to the save_dir
+        if not isinstance(trainer, ClassificationTrainer):
+            self.run.log(
+                {
+                    "train_batch_images": [
+                        wandb.Image(str(image_path), caption=image_path.stem)
+                        for image_path in trainer.save_dir.glob("train_batch*.jpg")
+                    ]
+                }
+            )
+
+    def on_fit_epoch_end(self, trainer: BaseTrainer) -> None:
+        """On fit epoch end we log all the best metrics and model detail to Weights & Biases run summary."""
+        assert self.run is not None
+        if trainer.epoch == 0:
+            speeds = [
+                trainer.validator.speed.get(
+                    key,
+                )
+                for key in (1, "inference")
+            ]
+            speed = speeds[0] if speeds[0] else speeds[1]
+            if speed:
+                self.run.summary.update(
+                    {
+                        "model/speed(ms/img)": round(speed, 3),
+                    }
+                )
+        if trainer.best_fitness == trainer.fitness:
+            self.run.summary.update(
+                {
+                    "best/epoch": trainer.epoch + 1,
+                    **{f"best/{key}": val for key, val in trainer.metrics.items()},
+                }
+            )
+
+    def on_train_end(self, trainer: BaseTrainer) -> None:
+        """On train end we log all the media, including plots, images and best model artifact to Weights & Biases."""
+        # Currently only the detection and segmentation trainers save images to the save_dir
+        assert self.run is not None
+        if not isinstance(trainer, ClassificationTrainer):
+            assert self.run is not None
+            self.run.log(
+                {
+                    "plots": [
+                        wandb.Image(str(image_path), caption=image_path.stem)
+                        for image_path in trainer.save_dir.glob("*.png")
+                    ],
+                    "val_images": [
+                        wandb.Image(str(image_path), caption=image_path.stem)
+                        for image_path in trainer.validator.save_dir.glob("val*.jpg")
+                    ],
+                },
+            )
+
+        if trainer.best.exists():
+            assert self.run is not None
+            self.run.log_artifact(
+                str(trainer.best),
+                type="model",
+                name=f"{self.run.name}_{trainer.args.task}.pt",
+                aliases=["best", f"epoch_{trainer.epoch + 1}"],
+            )
+
+    def on_model_save(self, trainer: BaseTrainer) -> None:
+        """On model save we log the model as an artifact to Weights & Biases."""
+        assert self.run is not None
+        self.run.log_artifact(
+            str(trainer.last),
+            type="model",
+            name=f"{self.run.name}_{trainer.args.task}.pt",
+            aliases=["last", f"epoch_{trainer.epoch + 1}"],
+        )
+
+    def teardown(self, _trainer: BaseTrainer) -> None:
+        """On teardown, we finish the Weights & Biases run and set it to None."""
+        assert self.run is not None
+        self.run.finish()
+        self.run = None
+
+    @property
+    def callbacks(
+        self,
+    ) -> Dict[str, Callable]:
+        """Property contains all the relevant callbacks to add to the YOLO model for the Weights & Biases logging."""
+        return {
+            "on_pretrain_routine_start": self.on_pretrain_routine_start,
+            "on_pretrain_routine_end": self.on_pretrain_routine_end,
+            "on_train_epoch_start": self.on_train_epoch_start,
+            "on_train_epoch_end": self.on_train_epoch_end,
+            "on_fit_epoch_end": self.on_fit_epoch_end,
+            "on_train_end": self.on_train_end,
+            "on_model_save": self.on_model_save,
+            "teardown": self.teardown,
+        }
+
+
+def add_callbacks(
+    yolo: YOLO,
+    run_name: Optional[str] = None,
+    project: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    resume: Optional[str] = None,
+    **kwargs: Optional[Any],
+) -> YOLO:
+    """A YOLO model wrapper that tracks metrics, and logs models to Weights & Biases.
+
+    Args:
+        yolo: A YOLOv8 model that's inherited from `:class:ultralytics.yolo.engine.model.YOLO`
+        run_name, str: The name of the Weights & Biases run, defaults to an auto generated name if `trainer.args.name` is not defined.
+        project, str: The name of the Weights & Biases project, defaults to `"YOLOv8"` if `trainer.args.project` is not defined.
+        tags, List[str]: A list of tags to be added to the Weights & Biases run, defaults to `["YOLOv8"]`.
+        resume, str: Whether to resume a previous run on Weights & Biases, defaults to `None`.
+        **kwargs: Additional arguments to be passed to `wandb.init()`.
+
+    Usage:
+    ```python
+    from wandb.integration.yolov8 import add_callbacks as add_wandb_callbacks
+
+    model = YOLO("yolov8n.pt")
+    add_wandb_callbacks(
+        model,
+    )
+    model.train(
+        data="coco128.yaml",
+        epochs=3,
+        imgsz=640,
+    )
+    ```
+    """
+    wandb.termwarn(
+        """The wandb callback is currently in beta and is subject to change based on updates to `ultralytics yolov8`.
+        The callback is tested and supported for ultralytics v8.0.43 and above.
+        Please report any issues to https://github.com/wandb/wandb/issues with the tag `yolov8`.
+        """,
+        repeat=False,
+    )
+    wandb.termwarn(
+        """This wandb callback is no longer functional and would be deprecated in the near future.
+        We recommend you to use the updated callback using `from wandb.integration.ultralytics import add_wandb_callback`.
+        The updated callback is tested and supported for ultralytics 8.0.167 and above.
+        You can refer to https://docs.wandb.ai/guides/integrations/ultralytics for the updated documentation.
+        Please report any issues to https://github.com/wandb/wandb/issues with the tag `yolov8`.
+        """,
+        repeat=False,
+    )
+
+    if RANK in [-1, 0]:
+        wandb_logger = WandbCallback(
+            yolo, run_name=run_name, project=project, tags=tags, resume=resume, **kwargs
+        )
+        for event, callback_fn in wandb_logger.callbacks.items():
+            yolo.add_callback(event, callback_fn)
+        return yolo
+    else:
+        wandb.termerror(
+            "The RANK of the process to add the callbacks was neither 0 or -1."
+            "No Weights & Biases callbacks were added to this instance of the YOLO model."
+        )
+    return yolo

evalkit_cambrian/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/setup.py

@@ -0,0 +1,86 @@
+from setuptools import setup, find_packages
+from setuptools.command.test import test as TestCommand
+import sys
+
+if sys.version_info[0] < 3:
+    import __builtin__ as builtins
+else:
+    import builtins
+
+# This is a bit (!) hackish: we are setting a global variable so that the main
+# graphql __init__ can detect if it is being loaded by the setup routine, to
+# avoid attempting to load components that aren't built yet:
+# the numpy distutils extensions that are used by scikit-learn to recursively
+# build the compiled extensions in sub-packages is based on the Python import
+# machinery.
+if 'test' not in sys.argv:
+    builtins.__GRAPHQL_SETUP__ = True
+
+version = __import__('graphql').get_version()
+
+install_requires = [
+    'six>=1.10.0',
+    'promise>=2.0'
+]
+
+tests_requires = [
+    'pytest==3.0.2',
+    'pytest-django==2.9.1',
+    'pytest-cov==2.3.1',
+    'coveralls',
+    'gevent==1.1rc1',
+    'six>=1.10.0',
+    'pytest-benchmark==3.0.0',
+    'pytest-mock==1.2',
+]
+
+class PyTest(TestCommand):
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = ['graphql', '-vrsx']
+        self.test_suite = True
+
+    def run_tests(self):
+        #import here, cause outside the eggs aren't loaded
+        import pytest
+        errno = pytest.main(self.test_args)
+        sys.exit(errno)
+
+
+setup(
+    name='graphql-core',
+    version=version,
+    description='GraphQL implementation for Python',
+    url='https://github.com/graphql-python/graphql-core',
+    download_url='https://github.com/graphql-python/graphql-core/releases',
+    author='Syrus Akbary, Jake Heinz, Taeho Kim',
+    author_email='Syrus Akbary <me@syrusakbary.com>, Jake Heinz <me@jh.gg>, Taeho Kim <dittos@gmail.com>',
+    license='MIT',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Topic :: Software Development :: Libraries',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: Implementation :: PyPy',
+        'License :: OSI Approved :: MIT License',
+        'Topic :: Database :: Front-Ends',
+        'Topic :: Internet :: WWW/HTTP',
+    ],
+
+    keywords='api graphql protocol rest',
+    packages=find_packages(exclude=['tests', 'tests_py35']),
+    install_requires=install_requires,
+    tests_require=tests_requires,
+    cmdclass = {'test': PyTest},
+    extras_require={
+        'gevent': [
+            'gevent==1.1rc1'
+        ],
+        'test': tests_requires
+    }
+)

evalkit_cambrian/lib/python3.10/site-packages/wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executor.py

@@ -0,0 +1,398 @@
+import collections
+from collections.abc import Iterable
+import functools
+import logging
+import sys
+
+from wandb_promise import Promise, promise_for_dict, is_thenable
+
+from ..error import GraphQLError, GraphQLLocatedError
+from ..pyutils.default_ordered_dict import DefaultOrderedDict
+from ..pyutils.ordereddict import OrderedDict
+from ..type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
+                    GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                    GraphQLSchema, GraphQLUnionType)
+from .base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
+                   collect_fields, default_resolve_fn, get_field_def,
+                   get_operation_root_type)
+from .executors.sync import SyncExecutor
+from .experimental.executor import execute as experimental_execute
+from .middleware import MiddlewareManager
+
+logger = logging.getLogger(__name__)
+
+
+use_experimental_executor = False
+
+
+def execute(schema, document_ast, root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None,
+            return_promise=False, middleware=None):
+    if use_experimental_executor:
+        return experimental_execute(
+            schema, document_ast, root_value, context_value,
+            variable_values, operation_name, executor,
+            return_promise, middleware
+        )
+
+    assert schema, 'Must provide schema'
+    assert isinstance(schema, GraphQLSchema), (
+        'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
+        'not multiple versions of GraphQL installed in your node_modules directory.'
+    )
+    if middleware:
+        if not isinstance(middleware, MiddlewareManager):
+            middleware = MiddlewareManager(*middleware)
+
+        assert isinstance(middleware, MiddlewareManager), (
+            'middlewares have to be an instance'
+            ' of MiddlewareManager. Received "{}".'.format(middleware)
+        )
+
+    if executor is None:
+        executor = SyncExecutor()
+
+    context = ExecutionContext(
+        schema,
+        document_ast,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        executor,
+        middleware
+    )
+
+    def executor(resolve, reject):
+        return resolve(execute_operation(context, context.operation, root_value))
+
+    def on_rejected(error):
+        context.errors.append(error)
+        return None
+
+    def on_resolve(data):
+        if not context.errors:
+            return ExecutionResult(data=data)
+        return ExecutionResult(data=data, errors=context.errors)
+
+    promise = Promise(executor).catch(on_rejected).then(on_resolve)
+    if return_promise:
+        return promise
+    context.executor.wait_until_finished()
+    return promise.get()
+
+
+def execute_operation(exe_context, operation, root_value):
+    type = get_operation_root_type(exe_context.schema, operation)
+    fields = collect_fields(
+        exe_context,
+        type,
+        operation.selection_set,
+        DefaultOrderedDict(list),
+        set()
+    )
+
+    if operation.operation == 'mutation':
+        return execute_fields_serially(exe_context, type, root_value, fields)
+
+    return execute_fields(exe_context, type, root_value, fields)
+
+
+def execute_fields_serially(exe_context, parent_type, source_value, fields):
+    def execute_field_callback(results, response_name):
+        field_asts = fields[response_name]
+        result = resolve_field(
+            exe_context,
+            parent_type,
+            source_value,
+            field_asts
+        )
+        if result is Undefined:
+            return results
+
+        if is_thenable(result):
+            def collect_result(resolved_result):
+                results[response_name] = resolved_result
+                return results
+
+            return result.then(collect_result, None)
+
+        results[response_name] = result
+        return results
+
+    def execute_field(prev_promise, response_name):
+        return prev_promise.then(lambda results: execute_field_callback(results, response_name))
+
+    return functools.reduce(execute_field, fields.keys(), Promise.resolve(collections.OrderedDict()))
+
+
+def execute_fields(exe_context, parent_type, source_value, fields):
+    contains_promise = False
+
+    final_results = OrderedDict()
+
+    for response_name, field_asts in fields.items():
+        result = resolve_field(exe_context, parent_type, source_value, field_asts)
+        if result is Undefined:
+            continue
+
+        final_results[response_name] = result
+        if is_thenable(result):
+            contains_promise = True
+
+    if not contains_promise:
+        return final_results
+
+    return promise_for_dict(final_results)
+
+
+def resolve_field(exe_context, parent_type, source, field_asts):
+    field_ast = field_asts[0]
+    field_name = field_ast.name.value
+
+    field_def = get_field_def(exe_context.schema, parent_type, field_name)
+    if not field_def:
+        return Undefined
+
+    return_type = field_def.type
+    resolve_fn = field_def.resolver or default_resolve_fn
+
+    # We wrap the resolve_fn from the middleware
+    resolve_fn_middleware = exe_context.get_field_resolver(resolve_fn)
+
+    # Build a dict of arguments from the field.arguments AST, using the variables scope to
+    # fulfill any variable references.
+    args = exe_context.get_argument_values(field_def, field_ast)
+
+    # The resolve function's optional third argument is a context value that
+    # is provided to every resolve function within an execution. It is commonly
+    # used to represent an authenticated user, or request-specific caches.
+    context = exe_context.context_value
+
+    # The resolve function's optional third argument is a collection of
+    # information about the current execution state.
+    info = ResolveInfo(
+        field_name,
+        field_asts,
+        return_type,
+        parent_type,
+        schema=exe_context.schema,
+        fragments=exe_context.fragments,
+        root_value=exe_context.root_value,
+        operation=exe_context.operation,
+        variable_values=exe_context.variable_values,
+    )
+
+    executor = exe_context.executor
+    result = resolve_or_error(resolve_fn_middleware, source, args, context, info, executor)
+
+    return complete_value_catching_error(
+        exe_context,
+        return_type,
+        field_asts,
+        info,
+        result
+    )
+
+
+def resolve_or_error(resolve_fn, source, args, context, info, executor):
+    try:
+        return executor.execute(resolve_fn, source, args, context, info)
+    except Exception as e:
+        logger.exception("An error occurred while resolving field {}.{}".format(
+            info.parent_type.name, info.field_name
+        ))
+        e.stack = sys.exc_info()[2]
+        return e
+
+
+def complete_value_catching_error(exe_context, return_type, field_asts, info, result):
+    # If the field type is non-nullable, then it is resolved without any
+    # protection from errors.
+    if isinstance(return_type, GraphQLNonNull):
+        return complete_value(exe_context, return_type, field_asts, info, result)
+
+    # Otherwise, error protection is applied, logging the error and
+    # resolving a null value for this field if one is encountered.
+    try:
+        completed = complete_value(exe_context, return_type, field_asts, info, result)
+        if is_thenable(completed):
+            def handle_error(error):
+                exe_context.errors.append(error)
+                return None
+
+            return completed.catch(handle_error)
+
+        return completed
+    except Exception as e:
+        exe_context.errors.append(e)
+        return None
+
+
+def complete_value(exe_context, return_type, field_asts, info, result):
+    """
+    Implements the instructions for completeValue as defined in the
+    "Field entries" section of the spec.
+
+    If the field type is Non-Null, then this recursively completes the value for the inner type. It throws a field
+    error if that completion returns null, as per the "Nullability" section of the spec.
+
+    If the field type is a List, then this recursively completes the value for the inner type on each item in the
+    list.
+
+    If the field type is a Scalar or Enum, ensures the completed value is a legal value of the type by calling the
+    `serialize` method of GraphQL type definition.
+
+    If the field is an abstract type, determine the runtime type of the value and then complete based on that type.
+
+    Otherwise, the field type expects a sub-selection set, and will complete the value by evaluating all
+    sub-selections.
+    """
+    # If field type is NonNull, complete for inner type, and throw field error if result is null.
+
+    if is_thenable(result):
+        return Promise.resolve(result).then(
+            lambda resolved: complete_value(
+                exe_context,
+                return_type,
+                field_asts,
+                info,
+                resolved
+            ),
+            lambda error: Promise.rejected(GraphQLLocatedError(field_asts, original_error=error))
+        )
+
+    # print return_type, type(result)
+    if isinstance(result, Exception):
+        raise GraphQLLocatedError(field_asts, original_error=result)
+
+    if isinstance(return_type, GraphQLNonNull):
+        return complete_nonnull_value(exe_context, return_type, field_asts, info, result)
+
+    # If result is null-like, return null.
+    if result is None:
+        return None
+
+    # If field type is List, complete each item in the list with the inner type
+    if isinstance(return_type, GraphQLList):
+        return complete_list_value(exe_context, return_type, field_asts, info, result)
+
+    # If field type is Scalar or Enum, serialize to a valid value, returning null if coercion is not possible.
+    if isinstance(return_type, (GraphQLScalarType, GraphQLEnumType)):
+        return complete_leaf_value(return_type, result)
+
+    if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
+        return complete_abstract_value(exe_context, return_type, field_asts, info, result)
+
+    if isinstance(return_type, GraphQLObjectType):
+        return complete_object_value(exe_context, return_type, field_asts, info, result)
+
+    assert False, u'Cannot complete value of unexpected type "{}".'.format(return_type)
+
+
+def complete_list_value(exe_context, return_type, field_asts, info, result):
+    """
+    Complete a list value by completing each item in the list with the inner type
+    """
+    assert isinstance(result, Iterable), \
+        ('User Error: expected iterable, but did not find one ' +
+         'for field {}.{}.').format(info.parent_type, info.field_name)
+
+    item_type = return_type.of_type
+    completed_results = []
+    contains_promise = False
+    for item in result:
+        completed_item = complete_value_catching_error(exe_context, item_type, field_asts, info, item)
+        if not contains_promise and is_thenable(completed_item):
+            contains_promise = True
+
+        completed_results.append(completed_item)
+
+    return Promise.all(completed_results) if contains_promise else completed_results
+
+
+def complete_leaf_value(return_type, result):
+    """
+    Complete a Scalar or Enum by serializing to a valid value, returning null if serialization is not possible.
+    """
+    # serialize = getattr(return_type, 'serialize', None)
+    # assert serialize, 'Missing serialize method on type'
+
+    return return_type.serialize(result)
+
+
+def complete_abstract_value(exe_context, return_type, field_asts, info, result):
+    """
+    Complete an value of an abstract type by determining the runtime type of that value, then completing based
+    on that type.
+    """
+    runtime_type = None
+
+    # Field type must be Object, Interface or Union and expect sub-selections.
+    if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
+        if return_type.resolve_type:
+            runtime_type = return_type.resolve_type(result, exe_context.context_value, info)
+        else:
+            runtime_type = get_default_resolve_type_fn(result, exe_context.context_value, info, return_type)
+
+    if isinstance(runtime_type, str):
+        runtime_type = info.schema.get_type(runtime_type)
+
+    if not isinstance(runtime_type, GraphQLObjectType):
+        raise GraphQLError(
+            ('Abstract type {} must resolve to an Object type at runtime ' +
+             'for field {}.{} with value "{}", received "{}".').format(
+                 return_type,
+                 info.parent_type,
+                 info.field_name,
+                 result,
+                 runtime_type,
+                 ),
+            field_asts
+        )
+
+    if not exe_context.schema.is_possible_type(return_type, runtime_type):
+        raise GraphQLError(
+            u'Runtime Object type "{}" is not a possible type for "{}".'.format(runtime_type, return_type),
+            field_asts
+        )
+
+    return complete_object_value(exe_context, runtime_type, field_asts, info, result)
+
+
+def get_default_resolve_type_fn(value, context, info, abstract_type):
+    possible_types = info.schema.get_possible_types(abstract_type)
+    for type in possible_types:
+        if callable(type.is_type_of) and type.is_type_of(value, context, info):
+            return type
+
+
+def complete_object_value(exe_context, return_type, field_asts, info, result):
+    """
+    Complete an Object value by evaluating all sub-selections.
+    """
+    if return_type.is_type_of and not return_type.is_type_of(result, exe_context.context_value, info):
+        raise GraphQLError(
+            u'Expected value of type "{}" but got: {}.'.format(return_type, type(result).__name__),
+            field_asts
+        )
+
+    # Collect sub-fields to execute to complete this value.
+    subfield_asts = exe_context.get_sub_fields(return_type, field_asts)
+    return execute_fields(exe_context, return_type, result, subfield_asts)
+
+
+def complete_nonnull_value(exe_context, return_type, field_asts, info, result):
+    """
+    Complete a NonNull value by completing the inner type
+    """
+    completed = complete_value(
+        exe_context, return_type.of_type, field_asts, info, result
+    )
+    if completed is None:
+        raise GraphQLError(
+            'Cannot return null for non-nullable field {}.{}.'.format(info.parent_type, info.field_name),
+            field_asts
+        )
+
+    return completed

evalkit_eagle/lib/python3.10/site-packages/scipy/misc/__init__.py

@@ -0,0 +1,6 @@
+import warnings
+warnings.warn(
+    "scipy.misc is deprecated and will be removed in 2.0.0",
+    DeprecationWarning,
+    stacklevel=2
+)

evalkit_eagle/lib/python3.10/site-packages/scipy/misc/common.py

@@ -0,0 +1,6 @@
+import warnings
+warnings.warn(
+    "scipy.misc.common is deprecated and will be removed in 2.0.0",
+    DeprecationWarning,
+    stacklevel=2
+)

evalkit_eagle/lib/python3.10/site-packages/scipy/misc/doccer.py

@@ -0,0 +1,6 @@
+import warnings
+warnings.warn(
+    "scipy.misc.doccer is deprecated and will be removed in 2.0.0",
+    DeprecationWarning,
+    stacklevel=2
+)