{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":19989,"databundleVersionId":1160143,"sourceType":"competition"}],"dockerImageVersionId":29963,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"## Importing dependencies\n","metadata":{}},{"cell_type":"code","source":"import os\nimport numpy as np \nimport pandas as pd \nfrom datetime import datetime\nimport time\nimport random\nfrom tqdm import tqdm_notebook as tqdm # progress bar\nimport matplotlib.pyplot as plt\n\n# torch\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import Dataset,DataLoader\nfrom torch.utils.data.sampler import SequentialSampler, RandomSampler\n\n# torchvision\nimport torchvision\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor, FasterRCNN\nfrom torchvision.models.detection.backbone_utils import resnet_fpn_backbone\n\n# sklearn\nfrom sklearn.model_selection import StratifiedKFold\n\n# CV\nimport cv2\n\n# Albumenatations\nimport albumentations as A\nfrom albumentations.pytorch.transforms import ToTensorV2\n\n# Glob\nfrom glob import glob\n\nimport warnings\nwarnings.filterwarnings('ignore') #Ignore \"future\" warnings and Data-Frame-Slicing warnings.","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Lets check our Hardware first\ngpu_info = !nvidia-smi\ngpu_info = '\\n'.join(gpu_info)\nif gpu_info.find('failed') >= 0:\n    print('Select the Runtime > \"Change runtime type\" menu to enable a GPU accelerator, ')\n    print('and then re-execute this cell.')\nelse:\n    print(gpu_info)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Configuration\n\n## Basic configuration for this model\n\nBelow you can change the base configuration, the impact on CV and LB score is quite high! Be careful to not choose a too high learning rate.","metadata":{}},{"cell_type":"code","source":"n_folds = 5\nseed = 2020\nnum_classes = 2\nBATCH_SIZE = 4\nLR = 0.05\n\n## Use more then 20 Epochs, we go for 20 epochs for demonstration purposes\nEPOCHS = 20\nimg_size_training = 800\n\n## Choose your optimizers:\nAdam = False\nif Adam: \n    Adam_config = {\"lr\" : 0.001, \"betas\" : (0.9, 0.999), \"eps\" : 1e-08}\nelse:\n    SGD_config = {\"lr\" : 0.001, \"momentum\" : 0.9, \"weight_decay\" : 0.001}","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Seed Everything\n\nSeeding everything for reproducible results.","metadata":{}},{"cell_type":"code","source":"def seed_everything(seed):\n    random.seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    np.random.seed(seed)\n    torch.manual_seed(seed)\n    torch.cuda.manual_seed(seed)\n    torch.backends.cudnn.deterministic = True\n    torch.backends.cudnn.benchmark = True\nseed_everything(seed)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Preparing the Data\n\nFor creating a cross-validation strategy we use code from Alex's awesome [kernel](https://www.kaggle.com/shonenkov/training-efficientdet).\nWe will create a cross-validation split in which the folds are made by preserving the percentage of samples (= stratisfied!) for each of the following \"classes\":\n* number of boxes \n* source\n\nFor this we first check the data:","metadata":{}},{"cell_type":"code","source":"bboxes_df = pd.read_csv('../input/global-wheat-detection/train.csv')\nbboxes_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"And then unpack the bbox coordinates into seperate columns x, y, w, h.","metadata":{}},{"cell_type":"code","source":"# get an array of arrays of all bboxes in the form [[x], [y], [w], [h]]\nbboxs = np.stack(bboxes_df['bbox'].apply(lambda x: np.fromstring(x[1:-1], sep = ',')))\n# save the values in the respective column\nfor i, column in enumerate(['x', 'y', 'w', 'h']):\n    bboxes_df[column] = bboxs[:,i]\nbboxes_df.drop(columns=['bbox'], inplace=True)\nbboxes_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Creating stratified Folds\nskf = StratifiedKFold(n_splits = n_folds, shuffle = True, random_state = seed)\n\ndf_folds = bboxes_df[['image_id']].copy()\ndf_folds.loc[:, 'bbox_count'] = 1\n\n# get number of bboxes for each image_id\ndf_folds = df_folds.groupby('image_id').count()\n\n# add [source] column\ndf_folds.loc[:, 'source'] = bboxes_df[['image_id', 'source']].groupby('image_id').min()['source']\n\n# concat two arays of strings: source and (_bboxcount // 15) to separate into folds\ndf_folds.loc[:, 'stratify_group'] = np.char.add(\n    df_folds['source'].values.astype(str),\n    df_folds['bbox_count'].apply(lambda x: f'_{x // 15}').values.astype(str))\ndf_folds.loc[:, 'fold'] = 0\n\nfor fold_number, (train_index, val_index) in enumerate(skf.split(        \n        X = df_folds.index,\n        y = df_folds['stratify_group'])):\n    df_folds.loc[df_folds.iloc[val_index].index, 'fold'] = fold_number","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Creating Dataset\n## Let's raise a glass* to create the Dataset!\n![champaign-clipart-champagne-glass-6.png](attachment:champaign-clipart-champagne-glass-6.png)\n\n*class","metadata":{},"attachments":{"champaign-clipart-champagne-glass-6.png":{"image/png":"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"}}},{"cell_type":"code","source":"DIR_TRAIN = '../input/global-wheat-detection/train'\n\nclass WheatDataset(Dataset):\n    def __init__(self,image_ids,dataframe,transforms = None):\n        self.image_ids = image_ids\n        self.df = dataframe\n        self.transforms = transforms\n        \n        \n    def __len__(self) -> int:\n        return self.image_ids.shape[0]\n    \n    def __getitem__(self,index):\n        image_id = self.image_ids[index]\n        records = self.df[self.df['image_id'] == image_id]\n        \n        image = cv2.imread(f'{DIR_TRAIN}/{image_id}.jpg', cv2.IMREAD_COLOR)\n        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB).astype(np.float32)\n        image /= 255.0\n        \n        # converting from Coco to Pascal_voc format        \n        boxes = records[['x', 'y', 'w', 'h']].values\n        boxes[:, 2] = boxes[:, 0] + boxes[:, 2]\n        boxes[:, 3] = boxes[:, 1] + boxes[:, 3]\n        \n        # calculate area of bbox\n        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])\n        area = torch.as_tensor(area, dtype=torch.float32)\n        \n        # there is only one target class: wheat \n        labels = torch.ones((boxes.shape[0],), dtype=torch.int64)\n        \n        \"\"\"\n        What is 'iscrowd' meaning and doing?:\n        iscrowd: For single, seperable objects iscrowd is set to zero.\n        If we want to do segmentation, for a closeby group or collection of objects\n        in the image, we set iscrowd=1, in which case RLE is used.\n        \"\"\"\n        # suppose all instances are not crowd\n        iscrowd = torch.zeros((records.shape[0],), dtype=torch.int64)\n        \n        target = {}\n        target['boxes'] = boxes\n        target['labels'] = labels\n        target['image_id'] = torch.tensor([index])\n        target['area'] = area\n        target['iscrowd'] = iscrowd\n        \n        if self.transforms:\n            sample = {\n                'image': image,\n                'bboxes': target['boxes'],\n                'labels': labels\n            }\n            sample = self.transforms(**sample)\n            image = sample['image']\n            \n            # if this creates issues, use target['boxes'] = torch.as_tensor(sample['bboxes']) instead of below line\n            # target['boxes'] = torch.stack(tuple(map(torch.tensor, zip(*sample['bboxes'])))).permute(1, 0)\n            target['boxes'] = torch.as_tensor(sample['bboxes'])\n            target['boxes'] = target['boxes'].float()\n        \n        return image, target, image_id","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Augmentations\nDue to the limited size of the dataset and the fact, that Imagenet pre-trained FasterRCNNs don't know a lot about Wheathead-Detection yet, we will use a lot of different augmentations.\nBut: More augmentations are not always leading to better results. Also the augmentations need to be somewhat reasonable. So be careful to not augment every single picture multiple times: Using Albumentations ```OneOf``` method helps a lot here.\nUsing [Cutmix](https://arxiv.org/abs/1905.04899) in this competition is a very good idea to ensure good regulariazion/generalization of your network.\n\nHowever, there are always things you should not do:\n![](https://pbs.twimg.com/media/Ea4T7DxWsAEi4Ga.jpg)\n","metadata":{}},{"cell_type":"code","source":"## Albumentations\n\ndef get_train_transforms():\n    return A.Compose(\n        [   A.OneOf([\n                A.HueSaturationValue(hue_shift_limit = 0.2, \n                                     sat_shift_limit = 0.2,\n                                     val_shift_limit = 0.2,\n                                     p = 0.3), \n            \n                A.RandomBrightnessContrast(brightness_limit = 0.2,                                             \n                                           contrast_limit = 0.2,\n                                           p = 0.3),\n                # RGB shift normally expects not-normalized images, so make sure to normalize the RGB shift!\n                A.RGBShift(r_shift_limit = 20/255, \n                           g_shift_limit = 20/255, \n                           b_shift_limit = 10/255,\n                           p = 0.3)\n            ], \n            p = 0.2),\n         \n            A.OneOf([\n                A.RandomGamma(gamma_limit = (80, 120),\n                              p = 0.3),\n                A.Blur(p = 0.6),\n                A.GaussNoise(var_limit = (0.01, 0.05), mean = 0, p = 0.05),\n                A.ToGray(p = 0.05)\n                ],\n                p = 0.1),\n\n            A.OneOf([\n                A.HorizontalFlip(p = 1), \n                A.VerticalFlip(p = 1),  \n                A.Transpose(p = 1),                \n                A.RandomRotate90(p = 1)\n                ], \n                p = 0.7),  \n         \n            A.RandomFog(fog_coef_lower = 0.1,\n                        fog_coef_upper = 0.2,\n                        p = 0.02),   \n         \n            A.RandomSizedBBoxSafeCrop(img_size_training, \n                                      img_size_training, \n                                      p = 0.05),         \n            A.Resize(height = img_size_training, \n                     width = img_size_training, \n                     p = 1),\n         \n            A.Cutout(num_holes = random.randint(1, 6),\n                     max_h_size = 64, \n                     max_w_size = 64,\n                     fill_value = 0, \n                     p = 0.15),\n         \n            ToTensorV2(p = 1.0),\n        ],\n        p = 1.0, bbox_params = {'format': 'pascal_voc', 'label_fields': ['labels']})\n\ndef get_valid_transforms():\n    return A.Compose([\n        A.Resize(height = img_size_training,\n                 width = img_size_training,\n                 p = 1),\n        \n        ToTensorV2(p = 1.0)\n    ], bbox_params = {'format': 'pascal_voc', 'label_fields': ['labels']})","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Validate Augmentations","metadata":{}},{"cell_type":"markdown","source":"It's always strongly recommended to check your input pictures into your model after augmentations, to ensure that not strange things happen.\n\nI've seen (and also accidently used)  \n```A.RGBShift(r_shift_limit = 20, \n            g_shift_limit = 20,\n            b_shift_limit = 10,\n            p = 0.3)```    \nin a training pipeline for normalized pictures, and guess what happend: They turned in completely yellow, blue or red. Why? Because RGBSHift expectes not-normalized pictures! So be sure you normalize RGB shift to get valid input data -->  \n```A.RGBShift(r_shift_limit = 20/255, \n            g_shift_limit = 20/255,\n            b_shift_limit = 10/255, \n            p = 0.3)```","metadata":{}},{"cell_type":"code","source":"## In several occasions in the next sections we will need to create a dataset and a dataloader.\n# In this section we create helper functions for this to stay DRY (dont repeast yourself).\n\ndef get_validation_datset(df):\n    return WheatDataset(\n    image_ids = df.index.values,\n    dataframe = bboxes_df,\n    transforms = get_valid_transforms()\n    )\n    \ndef get_train_datset(df):    \n    return WheatDataset(\n    image_ids = df.index.values,\n    dataframe = bboxes_df,\n    transforms = get_train_transforms()\n    )\n\ndef get_validation_data_loader(valid_dataset, batch_size = 16):\n    return DataLoader(\n    valid_dataset,\n    batch_size = batch_size,\n    shuffle = False,\n    num_workers = 4,\n    collate_fn = collate_fn\n    )    \n\ndef get_train_data_loader(train_dataset, batch_size = 16):\n    return DataLoader(\n    train_dataset,\n    batch_size = batch_size,\n    shuffle = False,\n    num_workers = 4,\n    collate_fn = collate_fn\n    ) \n\ndef collate_fn(batch):\n    return tuple(zip(*batch))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## Lets check some augmentations!\n\n# get a fold\ndf_train = df_folds[df_folds['fold'] != 0]\n\n# create train dataset and data-loader\ntrain_dataset = get_train_datset(df_train)\ntrain_data_loader = get_train_data_loader(train_dataset, batch_size = 16)\n\ndevice=torch.device('cuda')\nimages, targets, image_ids = next(iter(train_data_loader))\n\nimages = list(image.to(device) for image in images)\ntargets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n\n# plot some augmentations!\nfig, ax = plt.subplots(figsize=(20, 20),  \n                       nrows = 4,\n                       ncols = 4)\nfor i in range (16):    \n    boxes = targets[i]['boxes'].cpu().numpy().astype(np.int32)\n    sample = images[i].permute(1,2,0).cpu().numpy()\n    for box in boxes:\n        cv2.rectangle(sample,\n                      (box[0], box[1]),\n                      (box[2], box[3]),\n                      (220, 0, 0), 3)\n    \n    ax[i // 4][i % 4].imshow(sample)   ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Model\n\n","metadata":{}},{"cell_type":"markdown","source":"As mentioned in the introduction, we are using the default [ResNet50 pytroch implementation](https://kite.com/python/docs/torchvision.models.detection.fasterrcnn_resnet50_fpn) here.\nWe will start with defining a function to load and get the model, as we will be doing this several times in the later sections. Next, we will define an AverageMeter, tracking of the loss of our model.\nThen we can finally set up the training.","metadata":{}},{"cell_type":"code","source":"def get_model():    \n    # load pre-trained model incl. head\n    model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n\n    # get number of input features for the classifier custom head\n    in_features = model.roi_heads.box_predictor.cls_score.in_features\n\n    # replace the pre-trained head with a new one\n    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n\n    return model","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Training Function\n\n","metadata":{}},{"cell_type":"code","source":"class AverageMeter(object):\n    \"\"\"Computes and stores the average and current value\"\"\"\n    # initialize and reset to zero\n    def __init__(self):\n        self.reset()\n\n    # reset everything to zero    \n    def reset(self):\n        self.val = 0\n        self.avg = 0\n        self.sum = 0\n        self.count = 0\n\n    # update loss after each batch\n    def update(self, val, n=1):\n        self.val = val\n        self.sum += val * n\n        self.count += n\n        self.avg = self.sum / self.count","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def train_fn(data_loader,model,optimizer,device,scheduler,epoch):\n    # set pytorch to train mode, in which the model will return losses\n    model.train()\n        \n    summary_loss = AverageMeter()\n    \n    tk0 = tqdm(data_loader, total = len(data_loader))\n    \n    # actual training steps\n    for step, (images, targets, image_ids) in enumerate(tk0):   \n        \n        # if targets is empty, create empty target tensor        \n        if len(targets) < 1:\n            target['boxes'] = torch.zeros((0, 4))\n            \n        # prepare data\n        images = list(image.to(device) for image in images)\n        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]        \n\n        # calculate loss        \n        loss_dict = model(images, targets)        \n        losses = sum(loss for loss in loss_dict.values())\n                \n        # resets gradients of all optimized Tensors before next training step\n        optimizer.zero_grad() \n        \n        # computes derivative of the loss w.r.t. the parameters \n        losses.backward() \n        \n        # updates the parameter based on the gradients from previous step\n        optimizer.step()\n        \n        # updates the scheduler if it's defined\n        if scheduler is not None:\n            scheduler.step()\n            \n        summary_loss.update(losses.item(),BATCH_SIZE)\n        tk0.set_postfix(loss = summary_loss.avg)\n        \n    return summary_loss","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Evaluation Function","metadata":{}},{"cell_type":"markdown","source":"In order to select the best model, epoch & weights, we need to create a valid competition metric.\nIn this case, we take the very well coded version from [this notebook](https://www.kaggle.com/pestipeti/competition-metric-details-script). ","metadata":{}},{"cell_type":"code","source":"def calculate_iou(gt, pr, form='pascal_voc') -> float:\n    \"\"\"Calculates the Intersection over Union.\n\n    Args:\n        gt: (np.ndarray[Union[int, float]]) coordinates of the ground-truth box\n        pr: (np.ndarray[Union[int, float]]) coordinates of the prdected box\n        form: (str) gt/pred coordinates format\n            - pascal_voc: [xmin, ymin, xmax, ymax]\n            - coco: [xmin, ymin, w, h]\n    Returns:\n        (float) Intersection over union (0.0 <= iou <= 1.0)\n    \"\"\"\n    if form == 'coco':\n        gt = gt.copy()\n        pr = pr.copy()\n\n        gt[2] = gt[0] + gt[2]\n        gt[3] = gt[1] + gt[3]\n        pr[2] = pr[0] + pr[2]\n        pr[3] = pr[1] + pr[3]\n\n    # Calculate overlap area\n    dx = min(gt[2], pr[2]) - max(gt[0], pr[0]) + 1\n    \n    if dx < 0:\n        return 0.0\n    dy = min(gt[3], pr[3]) - max(gt[1], pr[1]) + 1\n\n    if dy < 0:\n        return 0.0\n\n    overlap_area = dx * dy\n\n    # Calculate union area\n    union_area = (\n            (gt[2] - gt[0] + 1) * (gt[3] - gt[1] + 1) +\n            (pr[2] - pr[0] + 1) * (pr[3] - pr[1] + 1) -\n            overlap_area\n    )\n\n    return overlap_area / union_area\n\ndef find_best_match(gts, pred, pred_idx, threshold = 0.5, form = 'pascal_voc', ious=None) -> int:\n    \"\"\"Returns the index of the 'best match' between the\n    ground-truth boxes and the prediction. The 'best match'\n    is the highest IoU. (0.0 IoUs are ignored).\n\n    Args:\n        gts: (List[List[Union[int, float]]]) Coordinates of the available ground-truth boxes\n        pred: (List[Union[int, float]]) Coordinates of the predicted box\n        pred_idx: (int) Index of the current predicted box\n        threshold: (float) Threshold\n        form: (str) Format of the coordinates\n        ious: (np.ndarray) len(gts) x len(preds) matrix for storing calculated ious.\n\n    Return:\n        (int) Index of the best match GT box (-1 if no match above threshold)\n    \"\"\"\n    best_match_iou = -np.inf\n    best_match_idx = -1\n    for gt_idx in range(len(gts)):\n        \n        if gts[gt_idx][0] < 0:\n            # Already matched GT-box\n            continue\n        \n        iou = -1 if ious is None else ious[gt_idx][pred_idx]\n\n        if iou < 0:\n            iou = calculate_iou(gts[gt_idx], pred, form = form)\n            \n            if ious is not None:\n                ious[gt_idx][pred_idx] = iou\n\n        if iou < threshold:\n            continue\n\n        if iou > best_match_iou:\n            best_match_iou = iou\n            best_match_idx = gt_idx\n\n    return best_match_idx\n\ndef calculate_precision(gts, preds, threshold = 0.5, form = 'coco', ious=None) -> float:\n    \"\"\"Calculates precision for GT - prediction pairs at one threshold.\n\n    Args:\n        gts: (List[List[Union[int, float]]]) Coordinates of the available ground-truth boxes\n        preds: (List[List[Union[int, float]]]) Coordinates of the predicted boxes,\n               sorted by confidence value (descending)\n        threshold: (float) Threshold\n        form: (str) Format of the coordinates\n        ious: (np.ndarray) len(gts) x len(preds) matrix for storing calculated ious.\n\n    Return:\n        (float) Precision\n    \"\"\"\n    n = len(preds)\n    tp = 0\n    fp = 0\n    \n    for pred_idx in range(n):\n\n        best_match_gt_idx = find_best_match(gts, preds[pred_idx], pred_idx,\n                                            threshold=threshold, form=form, ious=ious)\n\n        if best_match_gt_idx >= 0:\n            # True positive: The predicted box matches a gt box with an IoU above the threshold.\n            tp += 1\n            # Remove the matched GT box\n            gts[best_match_gt_idx] = -1\n        else:\n            # No match\n            # False positive: indicates a predicted box had no associated gt box.\n            fp += 1\n\n    # False negative: indicates a gt box had no associated predicted box.\n    fn = (gts.sum(axis=1) > 0).sum()\n\n    return tp / (tp + fp + fn)\n\n\n\ndef calculate_image_precision(gts, preds, thresholds = (0.5, ), form = 'coco') -> float:\n    \"\"\"Calculates image precision.\n\n    Args:\n        gts: (List[List[Union[int, float]]]) Coordinates of the available ground-truth boxes\n        preds: (List[List[Union[int, float]]]) Coordinates of the predicted boxes,\n               sorted by confidence value (descending)\n        thresholds: (float) Different thresholds\n        form: (str) Format of the coordinates\n\n    Return:\n        (float) Precision\n    \"\"\"\n    n_threshold = len(thresholds)\n    image_precision = 0.0\n    \n    ious = np.ones((len(gts), len(preds))) * -1\n    # ious = None\n\n    for threshold in thresholds:\n        precision_at_threshold = calculate_precision(gts.copy(), \n                                                     preds, \n                                                     threshold = threshold,\n                                                     form = form,\n                                                     ious = ious)\n        image_precision += precision_at_threshold / n_threshold\n\n    return image_precision\n","metadata":{"_kg_hide-input":true,"_kg_hide-output":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def eval_fn(data_loader, model, device):\n    model.eval()\n    summary_loss_eval = AverageMeter()\n    iou_thresholds = [x for x in np.arange(0.5, 0.76, 0.05)]\n    validation_image_precisions = []\n    \n    with torch.no_grad():\n        \n        tk0 = tqdm(data_loader, total=len(data_loader))\n        for step, (images, targets, image_ids) in enumerate(tk0):\n            \n            images = list(image.to(device) for image in images)\n            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n            \n            \"\"\"\n            In model.train() mode, model(images)  is returning losses.\n            We are using model.eval() mode --> it will return boxes and scores. \n            \"\"\"\n            outputs = model(images)\n\n            for i, image in enumerate(images):\n                boxes = outputs[i]['boxes'].data.cpu().numpy()\n                scores = outputs[i]['scores'].data.cpu().numpy()\n                gt_boxes = targets[i]['boxes'].cpu().numpy()\n                preds_sorted_idx = np.argsort(scores)[::-1]\n                preds_sorted = boxes[preds_sorted_idx]\n                image_precision = calculate_image_precision(preds_sorted,\n                                                            gt_boxes,\n                                                            thresholds = iou_thresholds,\n                                                            form = 'pascal_voc')\n                validation_image_precisions.append(image_precision)\n\n    valid_prec = np.mean(validation_image_precisions)\n        \n    return valid_prec","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Engine","metadata":{}},{"cell_type":"markdown","source":"In this section we will do the actual training, comining the previous defined functions to a full pipeline.","metadata":{}},{"cell_type":"code","source":"def run(fold):\n    summary_loss = AverageMeter()\n    \n    # split data in training and validation set based on the fold\n    df_train = df_folds[df_folds['fold'] != fold]\n    df_valid = df_folds[df_folds['fold'] == fold]\n    \n    # get data loaders\n    train_dataset = get_train_datset(df_train)\n    train_data_loader = get_train_data_loader(train_dataset, batch_size = BATCH_SIZE)\n    \n    validation_dataset = get_validation_datset(df_valid)\n    validation_data_loader = get_validation_data_loader(validation_dataset, batch_size = 16)\n          \n    # get GPU device\n    device = torch.device('cuda')\n    \n    # get model\n    model = get_model()\n    model = model.to(device)\n    \n    # get all trainable parameters for the optimizer\n    params = [p for p in model.parameters() if p.requires_grad]\n    \n    # get the configured optimizer\n    if Adam:\n        optimizer = torch.optim.Adam(params, **Adam_config)\n    else:\n        optimizer = torch.optim.SGD(params, **SGD_config)\n        \n    best_precision = 0.01\n    for epoch in range(EPOCHS):\n        \n        # reset loss for each new epoch\n        summary_loss.reset()\n                                \n        train_loss = train_fn(train_data_loader, \n                              model, optimizer, \n                              device, \n                              scheduler = None, \n                              epoch = epoch)\n        \n        valid_precision = eval_fn(validation_data_loader, \n                                  model,\n                                  device)\n        \n        print('|EPOCH {}| TRAIN_LOSS {}| VAL_PRECISION {}|'.format(\n            epoch+1,\n            train_loss.avg,\n            valid_precision))\n        \n        if valid_precision > best_precision:\n            best_precision = valid_precision\n            print('Best model found for Epoch {}'.format(epoch+1))\n            torch.save(model.state_dict(), f'FRCNN_best_{fold}.pth')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"run(fold = 0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### The model works as expected: \nThe loss is continuously dropping, the VAL_PRECISION is continuously increasing.\nUsing more epochs will lead to much better results and only the best model is saved in your OUTPUT folder.","metadata":{}},{"cell_type":"markdown","source":"# Sample visualization of predictions\n\nIn this step we load the best saved model and make our predictions.","metadata":{}},{"cell_type":"code","source":"def view_sample(df_valid,model,device):\n    '''\n    Code merged from Peter's & KnowNothing's great Kernels\n    https://www.kaggle.com/pestipeti/pytorch-starter-fasterrcnn-train\n    https://www.kaggle.com/tanulsingh077/end-to-end-object-detection-with-transformers-detr\n    '''\n    \n    validation_dataset = get_validation_datset(df_valid)\n    validation_data_loader = get_validation_data_loader(validation_dataset, batch_size = 16)\n    \n    # not needed\n    # images, targets, image_ids = next(iter(validation_data_loader))\n    # images = list(img.to(device) for img in images)\n    # targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n    \n    #_,h,w = images[0].shape # for de normalizing images\n    \n    images, targets, image_ids = next(iter(validation_data_loader))\n    images = list(img.to(device) for img in images)\n    targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n    \n    boxes_gt = targets[0]['boxes'].cpu().numpy().astype(np.int32)\n    sample = images[0].permute(1,2,0).cpu().numpy()\n    \n    model.to(device)\n    model.eval()\n    cpu_device = torch.device(\"cpu\")\n    #model.cuda()\n\n    outputs = model(images)\n    outputs = [{k: v.to(cpu_device) for k, v in t.items()} for t in outputs]\n    \n    fig, ax = plt.subplots(1, 1, figsize=(16, 8))\n\n    # paint ground_truth boxes (red)\n    for box in boxes_gt:\n        cv2.rectangle(sample,\n                      (box[0], box[1]),\n                      (box[2], box[3]),\n                      (220, 0, 0), 3)\n        \n    boxes = outputs[0]['boxes'].data.cpu().numpy()\n    scores = outputs[0]['scores'].data.cpu().numpy()\n          \n    # paint predicted boxes (blue)\n    pred_box_count = 0\n    for box,p in zip(boxes,scores):        \n        if p >0.5:\n            pred_box_count += 1\n            color = (0,0,220) \n            cv2.rectangle(sample,\n                  (box[0], box[1]),\n                  (box[2], box[3]),\n                  color, 2)\n    \n    \n    print(f\"Predicted {pred_box_count} BBoxes (blue); Number of GT BBoxes (red) : {len(boxes_gt)}\")\n    ax.set_axis_off()\n    ax.imshow(sample)       \n\n  ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = get_model()\n# load the best saved weights\nmodel.load_state_dict(torch.load(\"./FRCNN_best_0.pth\"))\n# show a prediction\nview_sample(df_folds[df_folds['fold'] == 0],\n            model = model,\n            device = torch.device('cuda'))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As expected, using less than 20 Epochs is not enough. Good results can be achived with 40+ Epochs, mostly using Colab for longer notebook availability.","metadata":{}},{"cell_type":"markdown","source":"# Conclusion\n\nAs Yolov5 is not really allowed due to its GPLv3 license (see [discussions](https://www.kaggle.com/c/global-wheat-detection/discussion/163433)), most probably FasterRCCN, EfficientDet or a combination of their results will win this competition. \n\nSmile!","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"# # # # # **SDD**","metadata":{}},{"cell_type":"markdown","source":"****Step 1: Import Required Libraries\nWe first import all the libraries necessary for data manipulation, model creation, and visualization.**","metadata":{}},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport os\nimport cv2\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision.models.detection.ssd import ssd300_vgg16\nfrom torchvision.transforms import functional as F\nimport albumentations as A\nfrom albumentations.pytorch import ToTensorV2\nimport matplotlib.pyplot as plt\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **Step 2: Load and Explore Dataset**\nThe dataset provides the bounding boxes for wheat heads in images. We load this data and examine its structure.","metadata":{}},{"cell_type":"code","source":"bboxes_df = pd.read_csv('../input/global-wheat-detection/train.csv')\nbboxes_df['bbox'] = bboxes_df['bbox'].apply(lambda x: eval(x))  # Convert string to list\nbboxes_df.head()\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **Step 3: Define the Custom Dataset\n# To work with the dataset in PyTorch, we create a custom Dataset class. This class:**\n\nLoads images from the directory.\nMatches them with the corresponding bounding boxes from the CSV.\nApplies preprocessing and augmentations.","metadata":{}},{"cell_type":"code","source":"class WheatDataset(Dataset):\n    def __init__(self, dataframe, image_dir, transforms=None):\n        self.dataframe = dataframe\n        self.image_dir = image_dir\n        self.transforms = transforms\n        self.image_ids = dataframe['image_id'].unique()\n\n    def __len__(self):\n        return len(self.image_ids)\n\n    def __getitem__(self, index):\n        image_id = self.image_ids[index]\n        image_path = os.path.join(self.image_dir, f\"{image_id}.jpg\")\n        image = cv2.imread(image_path)\n        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n        # Get bounding boxes\n        records = self.dataframe[self.dataframe['image_id'] == image_id]\n        boxes = np.stack(records['bbox'].values, axis=0)\n        labels = np.ones((boxes.shape[0],), dtype=np.int64)  # All wheat heads have label 1\n        \n        # Convert bbox to [x_min, y_min, x_max, y_max]\n        boxes[:, 2] = boxes[:, 0] + boxes[:, 2]  # x_max = x_min + width\n        boxes[:, 3] = boxes[:, 1] + boxes[:, 3]  # y_max = y_min + height\n\n        # Apply augmentations\n        if self.transforms:\n            transformed = self.transforms(image=image, bboxes=boxes, labels=labels)\n            image = transformed['image']\n            boxes = transformed['bboxes']\n            labels = transformed['labels']\n\n        target = {\n            'boxes': torch.tensor(boxes, dtype=torch.float32),\n            'labels': torch.tensor(labels, dtype=torch.int64),\n        }\n        \n        return image, target\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Step 4: Define Augmentations\nSSD requires inputs of a fixed size (300x300). Additionally, we apply augmentations like horizontal flipping and brightness changes to make the model robust.","metadata":{}},{"cell_type":"code","source":"train_transforms = A.Compose([\n    A.Resize(300, 300),  # Resize for SSD input size\n    A.HorizontalFlip(p=0.5),\n    A.RandomBrightnessContrast(p=0.2),\n    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n    ToTensorV2()\n], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['labels']))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Step 5: Create Dataset and DataLoader\nWe create an instance of the custom WheatDataset class and pass it to a DataLoader for batch processing.","metadata":{}},{"cell_type":"code","source":"train_dir = '../input/global-wheat-detection/train'\n\n# Create dataset and dataloader\ntrain_dataset = WheatDataset(bboxes_df, train_dir, transforms=train_transforms)\ntrain_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, collate_fn=lambda x: tuple(zip(*x)))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Step 6: Load Pre-trained SSD Model\nWe use an SSD300 model pre-trained on COCO and adapt it for wheat detection.","metadata":{}},{"cell_type":"code","source":"num_classes = 2  # Background + Wheat\nmodel = ssd300_vgg16(pretrained=True)\nmodel.head.classification_head.num_classes = num_classes\n\n# Update classification head\nin_channels = model.head.classification_head.num_classes\nmodel.head.classification_head = torch.nn.Conv2d(in_channels, num_classes * 8732, kernel_size=3, padding=1)\n\nmodel.to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Step 7: Train the Model\nThe training loop optimizes the model using SSD's multi-task loss, which combines classification and localization loss.","metadata":{}},{"cell_type":"code","source":"from torch.optim import Adam\n\noptimizer = Adam(model.parameters(), lr=0.001)\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nmodel.to(device)\n\nnum_epochs = 10\nfor epoch in range(num_epochs):\n    model.train()\n    running_loss = 0.0\n\n    for images, targets in train_loader:\n        images = torch.stack(images).to(device)\n        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n        \n        optimizer.zero_grad()\n        predictions = model(images)\n        loss_dict = model.compute_loss(predictions, targets)\n        loss = sum(loss_dict.values())\n        loss.backward()\n        optimizer.step()\n        \n        running_loss += loss.item()\n\n    print(f\"Epoch {epoch+1}, Loss: {running_loss / len(train_loader)}\")\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Step 8: Visualize Predictions\nFinally, we test the model and visualize predictions.","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def visualize_predictions(image, predictions, threshold=0.5):\n    image = image.permute(1, 2, 0).cpu().numpy()\n    plt.figure(figsize=(10, 10))\n    plt.imshow(image)\n    \n    for i, box in enumerate(predictions['boxes']):\n        score = predictions['scores'][i]\n        if score > threshold:\n            x_min, y_min, x_max, y_max = box.int().cpu().numpy()\n            plt.gca().add_patch(\n                plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min, fill=False, color='red', linewidth=2)\n            )\n            plt.text(x_min, y_min, f'{score:.2f}', color='white', fontsize=12, backgroundcolor='red')\n\n    plt.show()\n\nmodel.eval()\nwith torch.no_grad():\n    for images, _ in train_loader:\n        images = torch.stack(images).to(device)\n        predictions = model(images)\n        for i, image in enumerate(images):\n            visualize_predictions(image, predictions[i])\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"","metadata":{}}]}