\n R-CNN (Regions With CNNs)\n
The R-CNN (Regions With CNNs) network architecture was developed by a team at UC Berkley to apply Convolution Neural Networks to the object detection problem. The approaches to solving such problems that existed at that time approached the maximum of their capabilities and it was not possible to significantly improve their performance.
\n
CNNs have been good at image classification, and in this network they have essentially been applied to do the same thing. To do this, not the entire image was fed to the input of the CNN, but regions previously selected in a different way, in which presumably there are some objects. At that time there were several such approaches, the authors chose Selective Search, although they indicate that there are no special reasons for preferring it.
\n
A ready-made architecture, CaffeNet (AlexNet), was also used as a CNN network. Such neural networks, like others for the ImageNet image set, classify into 1000 classes. R-CNN was designed to detect objects of fewer classes (N=20 or 200), so the last CaffeNet classification layer was replaced with a layer with N+1 outputs (with an additional class for the background).
\n
Selective Search returned about 2000 regions of different sizes and aspect ratios, but CaffeNet accepts images of a fixed size of 227x227 pixels as input, so they had to be modified before submitting the regions to the network input. To do this, the image from the region was enclosed in the smallest enclosing square. Along that (smaller) side on which the fields were formed, several “context” (surrounding the region) pixels of the image were added, the rest of the field was not filled with anything. The resulting square was scaled to 227x227 and fed to the CaffeNet input.
\n
Even though the CNN was trained to recognize N+1 classes, it ended up being used only to extract a fixed 4096-dimensional feature vector. N linear SVMs were engaged in the direct determination of the object in the image, each of which carried out a binary classification according to its type of objects, determining whether there is one in the transferred region or not. In the original document, the whole procedure is illustrated by the following diagram:
\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"The R-CNN (Regions With CNNs) network architecture was developed by a team at UC Berkley to apply Convolution Neural Networks to the object detection problem. The approaches to solving such problems that existed at that time approached the maximum of their capabilities and it was not possible to significantly improve their performance.
\n
CNNs have been good at image classification, and in this network they have essentially been applied to do the same thing. To do this, not the entire image was fed to the input of the CNN, but regions previously selected in a different way, in which presumably there are some objects. At that time there were several such approaches, the authors chose Selective Search, although they indicate that there are no special reasons for preferring it.
\n
A ready-made architecture, CaffeNet (AlexNet), was also used as a CNN network. Such neural networks, like others for the ImageNet image set, classify into 1000 classes. R-CNN was designed to detect objects of fewer classes (N=20 or 200), so the last CaffeNet classification layer was replaced with a layer with N+1 outputs (with an additional class for the background).
\n
Selective Search returned about 2000 regions of different sizes and aspect ratios, but CaffeNet accepts images of a fixed size of 227x227 pixels as input, so they had to be modified before submitting the regions to the network input. To do this, the image from the region was enclosed in the smallest enclosing square. Along that (smaller) side on which the fields were formed, several “context” (surrounding the region) pixels of the image were added, the rest of the field was not filled with anything. The resulting square was scaled to 227x227 and fed to the CaffeNet input.
\n
Even though the CNN was trained to recognize N+1 classes, it ended up being used only to extract a fixed 4096-dimensional feature vector. N linear SVMs were engaged in the direct determination of the object in the image, each of which carried out a binary classification according to its type of objects, determining whether there is one in the transferred region or not. In the original document, the whole procedure is illustrated by the following diagram:
\n
\n Fast R-CNN\n
Despite the good results, the performance of R-CNN was still poor, especially for networks deeper than CaffeNet (such as VGG16). In addition, training the bounding box regressor and SVM required a large number of features to be saved to disk, so it was expensive in terms of storage size. The authors of Fast R-CNN suggested speeding up the process with a couple of modifications:
\n
The transformation of features that fell into different regions to a fixed size was performed using the RoIPooling procedure. The region window of width w and height h was divided into a grid with H × W cells of size h/H × w/W. (Document authors used W=H=7). For each such cell, Max Pooling was performed to select only one value, thus giving the resulting H×W feature matrix.
\n
Binary SVMs were not used, instead the selected features were passed to a fully connected layer and then to two parallel layers: softmax with K+1 outputs (one for each class + 1 for the background) and a bounding box regressor. The general network architecture looks like this:
\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"Despite the good results, the performance of R-CNN was still poor, especially for networks deeper than CaffeNet (such as VGG16). In addition, training the bounding box regressor and SVM required a large number of features to be saved to disk, so it was expensive in terms of storage size. The authors of Fast R-CNN suggested speeding up the process with a couple of modifications:
\n
- \n
- Pass through CNN not each of the 2000 candidate regions separately, but the entire image. The proposed regions are then superimposed on the resulting overall feature map; \n
- Instead of training three models (CNN, SVM, bbox regressor) independently, combine all training procedures into one. \n
The transformation of features that fell into different regions to a fixed size was performed using the RoIPooling procedure. The region window of width w and height h was divided into a grid with H × W cells of size h/H × w/W. (Document authors used W=H=7). For each such cell, Max Pooling was performed to select only one value, thus giving the resulting H×W feature matrix.
\n
Binary SVMs were not used, instead the selected features were passed to a fully connected layer and then to two parallel layers: softmax with K+1 outputs (one for each class + 1 for the background) and a bounding box regressor. The general network architecture looks like this:
\n
\n Faster R-CNN\n
After the improvements made in Fast R-CNN, the mechanism for generating candidate regions turned out to be the bottleneck of the neural network. In 2015, the team at Microsoft Research was able to make this phase much faster. They proposed to calculate the regions not from the original image, but again from the feature map obtained from CNN. To do this, a module called the Region Proposal Network (RPN) was added. The new architecture looks like this:
\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"After the improvements made in Fast R-CNN, the mechanism for generating candidate regions turned out to be the bottleneck of the neural network. In 2015, the team at Microsoft Research was able to make this phase much faster. They proposed to calculate the regions not from the original image, but again from the feature map obtained from CNN. To do this, a module called the Region Proposal Network (RPN) was added. The new architecture looks like this:
\n
\nWithin the framework of RPN, a “mini-neural network” with a small (3x3) window slides along the extracted CNN features. The values obtained with its help are transferred to two parallel fully connected layers: box-regression layer (reg) and box-classification layer (cls). The outputs of these layers are based on the so-called anchors: k frames for each position of the sliding window, with different sizes and aspect ratios. The reg layer for each such anchor produces 4 coordinates that adjust the position of the enclosing frame; cls-layer produces two numbers each - the probabilities that the frame contains at least some object or that it does not. This is illustrated in the document as follows:\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"\n Mask R-CNN\n
Mask R-CNN develops the Faster R-CNN architecture by adding another branch that predicts the position of the mask covering the found object, and thus solves the instance segmentation problem. The mask is simply a rectangular matrix, in which 1 at some position means that the corresponding pixel belongs to an object of a given class, 0 means that the pixel does not belong to the object.
\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"import torchvision\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor\nfrom torchvision.models.detection.mask_rcnn import MaskRCNNPredictor","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:13:31.026288Z","iopub.execute_input":"2024-07-09T07:13:31.026707Z","iopub.status.idle":"2024-07-09T07:13:32.950674Z","shell.execute_reply.started":"2024-07-09T07:13:31.026672Z","shell.execute_reply":"2024-07-09T07:13:32.949482Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_model(num_classes: int):\n # load an instance segmentation model pre-trained on COCO\n model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=\"DEFAULT\")\n\n # get number of input features for the classifier\n in_features = model.roi_heads.box_predictor.cls_score.in_features\n # replace the pre-trained head with a new one\n model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n\n # now get the number of input features for the mask classifier\n in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels\n hidden_layer = 256\n # and replace the mask predictor with a new one\n model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,\n hidden_layer,\n num_classes)\n\n return model","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:13:43.597519Z","iopub.execute_input":"2024-07-09T07:13:43.598393Z","iopub.status.idle":"2024-07-09T07:13:43.606521Z","shell.execute_reply.started":"2024-07-09T07:13:43.598354Z","shell.execute_reply":"2024-07-09T07:13:43.605251Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = get_model(4)","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:13:45.463588Z","iopub.execute_input":"2024-07-09T07:13:45.464521Z","iopub.status.idle":"2024-07-09T07:13:47.93586Z","shell.execute_reply.started":"2024-07-09T07:13:45.464476Z","shell.execute_reply":"2024-07-09T07:13:47.934594Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Mask R-CNN develops the Faster R-CNN architecture by adding another branch that predicts the position of the mask covering the found object, and thus solves the instance segmentation problem. The mask is simply a rectangular matrix, in which 1 at some position means that the corresponding pixel belongs to an object of a given class, 0 means that the pixel does not belong to the object.
\n
\n Transforming the data\n
Firstly, we absolutely need to bring the pictures to a single size and also normalize them. It would also not be bad to augment our data. After all, we are now working not with an image and its single mask as in semantic segmentation, but with individual instances, their masks and boxes. In this case, we can ignore color transformations, but all spatial transformations change both box and mask coordinates. In this case, we must take this into account. A library called albumentations is used. It easily take into account all the transformations.
\n
","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"import albumentations as A\nfrom albumentations.pytorch.transforms import ToTensorV2","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:13:52.05418Z","iopub.execute_input":"2024-07-09T07:13:52.054604Z","iopub.status.idle":"2024-07-09T07:13:53.233274Z","shell.execute_reply.started":"2024-07-09T07:13:52.054568Z","shell.execute_reply":"2024-07-09T07:13:53.232136Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Firstly, we absolutely need to bring the pictures to a single size and also normalize them. It would also not be bad to augment our data. After all, we are now working not with an image and its single mask as in semantic segmentation, but with individual instances, their masks and boxes. In this case, we can ignore color transformations, but all spatial transformations change both box and mask coordinates. In this case, we must take this into account. A library called albumentations is used. It easily take into account all the transformations.
\n
\n Transforms for training\n
","metadata":{}},{"cell_type":"code","source":"train_transforms = [\n A.Resize(512, 512, p=1), \n A.HorizontalFlip(p=0.5),\n A.VerticalFlip(p=0.5),\n A.RandomBrightnessContrast(p=0.45),\n A.HueSaturationValue(p=0.35),\n \n A.OneOf([\n A.MotionBlur(),\n A.Blur(blur_limit=3),\n A.MedianBlur(blur_limit=3),\n A.GaussNoise()\n ], p=0.10\n ),\n \n A.Normalize(),\n ToTensorV2()\n]","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:13:56.589793Z","iopub.execute_input":"2024-07-09T07:13:56.591049Z","iopub.status.idle":"2024-07-09T07:13:56.599251Z","shell.execute_reply.started":"2024-07-09T07:13:56.591007Z","shell.execute_reply":"2024-07-09T07:13:56.597786Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\n And for validation\n
","metadata":{}},{"cell_type":"code","source":"val_transforms = [\n A.Resize(512, 512, p=1), \n A.Normalize(),\n ToTensorV2()\n]","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:00.544247Z","iopub.execute_input":"2024-07-09T07:14:00.54469Z","iopub.status.idle":"2024-07-09T07:14:00.550654Z","shell.execute_reply.started":"2024-07-09T07:14:00.544656Z","shell.execute_reply":"2024-07-09T07:14:00.549335Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Dataset\n\n The dataset should act as an interface for getting images and a dictionary with target data.\n
","metadata":{}},{"cell_type":"markdown","source":"\n
","metadata":{}},{"cell_type":"code","source":"from torch.utils.data import Dataset\nimport albumentations as A\nimport torchvision.transforms as T\nimport cv2\nimport os\nimport yaml\nfrom typing import Literal, Any, Union\nfrom tqdm import tqdm\nimport json","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:04.477793Z","iopub.execute_input":"2024-07-09T07:14:04.47886Z","iopub.status.idle":"2024-07-09T07:14:04.486004Z","shell.execute_reply.started":"2024-07-09T07:14:04.478784Z","shell.execute_reply":"2024-07-09T07:14:04.484763Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class HuBMAPDataset(Dataset):\n def __init__(self,\n stage: Literal[\"train\", \"val\"],\n config_path: str,\n transforms: Union[A.Compose, T.Compose] = None,\n *args, **kwargs\n ):\n \n self.config = self.load_config(config_path)\n self.images_dirpath = None\n self.labels_dirpath = None\n self.__define_paths(stage)\n \n self.names = self.config[\"names\"]\n self.num_classes = len(self.names) \n self.samples = os.listdir(self.labels_dirpath)\n \n if transforms:\n self.bbox_params = {\n \"format\":\"pascal_voc\",\n \"min_area\": 0,\n \"min_visibility\": 0,\n \"label_fields\": [\"category_id\"]\n }\n self.transforms = A.Compose(transforms, bbox_params=self.bbox_params)\n \n @staticmethod\n def load_config(path: str) -> dict:\n with open(path, mode=\"r\") as f:\n data = yaml.load(stream=f, Loader=yaml.SafeLoader)\n return data\n\n def __len__(self) -> int:\n return len(self.samples)\n\n def __getitem__(self, idx: int) -> tuple[torch.Tensor, dict]:\n filename = self.samples[idx].split(\".\")[0]\n paths = self._get_paths(filename)\n image = cv2.imread(paths[\"image\"], cv2.COLOR_BGR2RGB) \n target = self._get_target(paths[\"label\"])\n target[\"image_id\"] = torch.tensor([idx])\n if self.transforms:\n image, target = self.transform(image, target)\n return image, target\n \n def transform(self, image: np.ndarray, target: dict) -> tuple[torch.Tensor, dict]:\n transformed = self.transforms(\n image=image, masks=target[\"masks\"],\n bboxes=target[\"boxes\"], \n category_id=target[\"labels\"]\n )\n \n image = transformed[\"image\"]\n target[\"masks\"] = torch.as_tensor(\n np.array(list(map(np.array, transformed[\"masks\"])), dtype=np.uint8)\n ) \n \n target[\"labels\"] = torch.tensor(transformed[\"category_id\"])\n target[\"boxes\"] = torch.as_tensor(transformed[\"bboxes\"], dtype=torch.float32)\n target[\"area\"] = self.__get_area(target[\"boxes\"])\n return image, target\n \n def __define_paths(self, stage: Literal[\"train\", \"val\"]) -> None:\n data_dirpath = self.config[stage]\n self.images_dirpath = os.path.join(data_dirpath, \"images\")\n self.labels_dirpath = os.path.join(data_dirpath, \"labels\")\n \n def _get_paths(self, filename: str) -> dict:\n image_path = os.path.join(self.images_dirpath, f\"{filename}.tif\")\n label_path = os.path.join(self.labels_dirpath, f\"{filename}.txt\")\n return {\n \"image\": image_path,\n \"label\": label_path\n }\n \n @staticmethod\n def _get_target_sample() -> dict:\n return {\n \"boxes\": [],\n \"masks\": [],\n \"area\": [],\n \"labels\": [],\n \"iscrowd\": None,\n \"image_id\": None\n }\n\n def _get_target(self, annotations_path: str) -> dict:\n target = self._get_target_sample()\n\n with open(annotations_path, \"r\") as file:\n for line in file:\n label = int(line[0])\n coordinates = np.array(list(map(int, line[1:].split()))).reshape(1, -1, 2)\n mask = self.__get_mask(label, coordinates)\n box = self.__get_box(mask)\n target[\"masks\"].append(mask) \n target[\"boxes\"].append(box)\n target[\"labels\"].append(label)\n \n num_objs = len(target[\"labels\"])\n target[\"iscrowd\"] = torch.zeros((num_objs,), dtype=torch.int64)\n return target \n\n @staticmethod\n def __get_mask(label: int, coordinates: np.ndarray) -> np.ndarray:\n mask = np.zeros((512, 512), dtype=np.uint8)\n return cv2.fillPoly(\n mask, pts=coordinates,\n color=(label, label, label)\n )\n \n @staticmethod\n def __get_box(mask: np.ndarray) -> list[np.ndarray, ...]:\n pos = np.nonzero(mask)\n xmin = np.min(pos[1])\n xmax = np.max(pos[1])\n ymin = np.min(pos[0])\n ymax = np.max(pos[0])\n return [xmin, ymin, xmax, ymax]\n \n @staticmethod\n def __get_area(boxes: list[list, ...]) -> torch.Tensor:\n return (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:06.525837Z","iopub.execute_input":"2024-07-09T07:14:06.52625Z","iopub.status.idle":"2024-07-09T07:14:06.559697Z","shell.execute_reply.started":"2024-07-09T07:14:06.526217Z","shell.execute_reply":"2024-07-09T07:14:06.558028Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"- \n
image: a PIL Image of size
(H, W)\ntarget: a dict containing the following fields
\n- \n
boxes (FloatTensor[N, 4]): the coordinates of theN\nbounding boxes in[x0, y0, x1, y1]format, ranging from0\ntoWand0toH\nlabels (Int64Tensor[N]): the label for each bounding box.0represents always the background class. \nimage_id (Int64Tensor[1]): an image identifier. It should be\nunique between all the images in the dataset, and is used during\nevaluation \narea (Tensor[N]): The area of the bounding box. This is used\nduring evaluation with the COCO metric, to separate the metric\nscores between small, medium and large boxes. \niscrowd (UInt8Tensor[N]): instances with iscrowd=True will be\nignored during evaluation. \n(optionally)
masks (UInt8Tensor[N, H, W]): The segmentation\nmasks for each one of the objects \n(optionally)
keypoints (FloatTensor[N, K, 3]): For each one of\nthe N objects, it contains the K keypoints in\n[x, y, visibility]format, defining the object. visibility=0\nmeans that the keypoint is not visible. Note that for data\naugmentation, the notion of flipping a keypoint is dependent on\nthe data representation, and you should probably adapt\nreferences/detection/transforms.pyfor your new keypoint\nrepresentation \n
\n
\n Dataset for training\n
","metadata":{}},{"cell_type":"code","source":"train_dataset = HuBMAPDataset(\n stage=\"train\",\n config_path=coco.config_path,\n transforms=train_transforms\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:11.160273Z","iopub.execute_input":"2024-07-09T07:14:11.160717Z","iopub.status.idle":"2024-07-09T07:14:11.170543Z","shell.execute_reply.started":"2024-07-09T07:14:11.160681Z","shell.execute_reply":"2024-07-09T07:14:11.169257Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\n Dataset for validation\n
","metadata":{}},{"cell_type":"code","source":"val_dataset = HuBMAPDataset(\n stage=\"val\",\n config_path=coco.config_path,\n transforms=val_transforms\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:14.048145Z","iopub.execute_input":"2024-07-09T07:14:14.048571Z","iopub.status.idle":"2024-07-09T07:14:14.056278Z","shell.execute_reply.started":"2024-07-09T07:14:14.048537Z","shell.execute_reply":"2024-07-09T07:14:14.054925Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Dataloaders\n\n Manipulating the unloading of data\n
Dataloaders efficiently manage the loading and unloading of mastaba data(data model and technology stack utilized in the “Mastaba” system) for neural network training. This involves:\n \nLazy Iteration: Data is loaded into memory only when needed and unloaded immediately after use, reducing RAM usage.\nMemory Management: Data stays briefly in RAM but longer in video memory.\n \nSimplified Handling: Modern approaches abstract away low-level data management, focusing on using high-level data loaders.\nThis approach optimizes memory usage and simplifies data handling in complex, distributed applications..
\n
","metadata":{}},{"cell_type":"code","source":"from torch.utils.data import DataLoader","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:16.913233Z","iopub.execute_input":"2024-07-09T07:14:16.913721Z","iopub.status.idle":"2024-07-09T07:14:16.919497Z","shell.execute_reply.started":"2024-07-09T07:14:16.913682Z","shell.execute_reply":"2024-07-09T07:14:16.918132Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Dataloaders efficiently manage the loading and unloading of mastaba data(data model and technology stack utilized in the “Mastaba” system) for neural network training. This involves:\n \nLazy Iteration: Data is loaded into memory only when needed and unloaded immediately after use, reducing RAM usage.\nMemory Management: Data stays briefly in RAM but longer in video memory.\n \nSimplified Handling: Modern approaches abstract away low-level data management, focusing on using high-level data loaders.\nThis approach optimizes memory usage and simplifies data handling in complex, distributed applications..
\n
\n Dataloader for training\n
","metadata":{}},{"cell_type":"code","source":"train_dataloader = DataLoader(\n dataset=train_dataset,\n batch_size=16, \n shuffle=True,\n pin_memory=True,\n num_workers=4,\n collate_fn=lambda x: tuple(zip(*x))\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:19.281257Z","iopub.execute_input":"2024-07-09T07:14:19.281664Z","iopub.status.idle":"2024-07-09T07:14:19.288422Z","shell.execute_reply.started":"2024-07-09T07:14:19.28163Z","shell.execute_reply":"2024-07-09T07:14:19.287091Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\n And for validation\n
","metadata":{}},{"cell_type":"code","source":"val_dataloader = DataLoader(\n dataset=val_dataset,\n batch_size=16, \n shuffle=False,\n pin_memory=True,\n num_workers=4,\n collate_fn=lambda x: tuple(zip(*x))\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-09T07:14:21.897836Z","iopub.execute_input":"2024-07-09T07:14:21.898231Z","iopub.status.idle":"2024-07-09T07:14:21.904221Z","shell.execute_reply.started":"2024-07-09T07:14:21.898201Z","shell.execute_reply":"2024-07-09T07:14:21.902883Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Weights and biases\n \n \n ![](\"https://img.shields.io/pypi/v/wandb\")
![](\"https://img.shields.io/conda/vn/conda-forge/wandb\")
![](\"https://img.shields.io/circleci/build/github/wandb/wandb/main\")
![](\"https://img.shields.io/codecov/c/gh/wandb/wandb\")
\n ![](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
\n