{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Analyzing Bad Batches - What Wheat Images does FasterRCNN Struggle With ?\n\nIn a previous notebook, we gave a hyperparameter sweep template using the Weights and Biases library: [Notebook](http://https://www.kaggle.com/kshen3778/hyperparameter-search-for-fasterrcnn?scriptVersionId=36233123)\n\nThis notebook will look at how a model can perform differently on different batches of images and go more into depth on the W&B bounding box logging feature.\nBecause our wheat dataset is collected from different geographical regions that vary visually, this may result in differing performance on different images. This notebook uses [Weights and Biases library](https://docs.wandb.com/)'s logging functionality with FasterRCNN in order to see what data the model is performing poorly on. We also look at how shuffling can create batches that are representative of the data.\n\nWe run our model for 30 epochs. We reserve approximately 75% of images as training data and 25% as validation for logging. An explanation of the results is available at the end of the notebook.\n\n\n## [Explore Results in a Live Dashboard →](https://app.wandb.ai/authors/GWD-fasterRCNN?workspace=user-kshen)\n![](https://i.imgur.com/5YqjGr7.png)\n\n\n- [W&B for Kaggle](https://www.wandb.com/kaggle)\n\n\n- Original FasterRCNN notebooks (@pestipeti):\n    - [Kernel 1](https://www.kaggle.com/pestipeti/pytorch-starter-fasterrcnn-train)\n\n    - [Kernel 2](https://www.kaggle.com/pestipeti/pytorch-starter-fasterrcnn-inference)","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# Setup","execution_count":null},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport cv2\nimport os\nimport re\nimport gc\nimport time\nimport random\nfrom sklearn.model_selection import train_test_split\n\nfrom PIL import Image\n\nimport albumentations as A\nfrom albumentations.pytorch.transforms import ToTensorV2\n\nimport torch\nimport torchvision\n\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor\nfrom torchvision.models.detection import FasterRCNN\nfrom torchvision.models.detection.rpn import AnchorGenerator\n\nfrom torch.utils.data import DataLoader, Dataset\nfrom torch.utils.data.sampler import SequentialSampler\n\nfrom matplotlib import pyplot as plt\nDIR_INPUT = '/kaggle/input/global-wheat-detection'\nDIR_TRAIN = f'{DIR_INPUT}/train'\nDIR_TEST = f'{DIR_INPUT}/test'\n\nseed = 42\nnp.random.seed(seed)\ntorch.manual_seed(seed)\ntorch.cuda.manual_seed(seed)\ntorch.backends.cudnn.deterministic = True\nrandom.seed(seed)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Install + import Weights and Biases\n!pip install --upgrade wandb\nimport wandb","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_df = pd.read_csv(f'{DIR_INPUT}/train.csv')\ntrain_df.shape\ntrain_df.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Extract the bbox column and explode it into x,y,w,h\ntrain_df['x'] = -1\ntrain_df['y'] = -1\ntrain_df['w'] = -1\ntrain_df['h'] = -1\n\ndef expand_bbox(x):\n    r = np.array(re.findall(\"([0-9]+[.]?[0-9]*)\", x))\n    if len(r) == 0:\n        r = [-1, -1, -1, -1]\n    return r\n\ntrain_df[['x', 'y', 'w', 'h']] = np.stack(train_df['bbox'].apply(lambda x: expand_bbox(x)))\ntrain_df.drop(columns=['bbox'], inplace=True)\ntrain_df['x'] = train_df['x'].astype(np.float)\ntrain_df['y'] = train_df['y'].astype(np.float)\ntrain_df['w'] = train_df['w'].astype(np.float)\ntrain_df['h'] = train_df['h'].astype(np.float)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Train-Validation Split","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"image_ids = train_df['image_id'].unique()\n\n#Shuffled\n#train_ids, valid_ids = train_test_split(image_ids, test_size=0.2, random_state=seed)\n\n#Non-shuffled (default)\n#First 75% of the data is training, last 25% is validation\nvalid_ids = image_ids[-674:]\ntrain_ids = image_ids[:-674]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(image_ids.shape)\nprint(valid_ids.shape)\nprint(train_ids.shape)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#take the bounding boxes and put them into their respective category (train, valid) by id \nvalid_df = train_df[train_df['image_id'].isin(valid_ids)]\ntrain_df = train_df[train_df['image_id'].isin(train_ids)]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class WheatDataset(Dataset):\n\n    def __init__(self, dataframe, image_dir, transforms=None):\n        super().__init__()\n\n        self.image_ids = dataframe['image_id'].unique() #all images\n        self.df = dataframe\n        self.image_dir = image_dir\n        self.transforms = transforms\n\n    def __getitem__(self, index: int):\n\n        image_id = self.image_ids[index]\n        records = self.df[self.df['image_id'] == image_id]\n        \n        #load image and normalize image pixels to 0-1\n        image = cv2.imread(f'{self.image_dir}/{image_id}.jpg', cv2.IMREAD_COLOR)\n        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB).astype(np.float32)\n        image /= 255.0\n        \n        boxes = records[['x', 'y', 'w', 'h']].values\n        #turn each bounding box into format [x_start, y_start, x_end, y_end]\n        boxes[:, 2] = boxes[:, 0] + boxes[:, 2]\n        boxes[:, 3] = boxes[:, 1] + boxes[:, 3]\n        \n        #calculate areas of each bounding box\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 class\n        labels = torch.ones((records.shape[0],), dtype=torch.int64)\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 #all boxes are labelled as 1 (wheat head)\n        # target['masks'] = None\n        target['image_id'] = torch.tensor([index])\n        target['area'] = area\n        target['iscrowd'] = iscrowd\n        \n        #apply transformations to this image\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            target['boxes'] = torch.stack(tuple(map(torch.tensor, zip(*sample['bboxes'])))).permute(1, 0)\n\n        return image, target\n\n    def __len__(self) -> int:\n        return self.image_ids.shape[0]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Albumentations (image data augmentation)\ndef get_train_transform():\n    return A.Compose([\n        A.Flip(0.5),\n        ToTensorV2(p=1.0)\n    ], bbox_params={'format': 'pascal_voc', 'label_fields': ['labels']})\n\ndef get_valid_transform():\n    return A.Compose([\n        ToTensorV2(p=1.0)\n    ], bbox_params={'format': 'pascal_voc', 'label_fields': ['labels']})\n\n#Collate function\ndef collate_fn(batch):\n    return tuple(zip(*batch))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#IOU + MAP Metric Calculation\nfrom collections import namedtuple\nfrom typing import List, Union\n\nBox = namedtuple('Box', 'xmin ymin xmax ymax')\n\n\ndef calculate_iou(gt: List[Union[int, float]],\n                  pred: List[Union[int, float]],\n                  form: str = 'pascal_voc') -> float:\n    \"\"\"Calculates the IoU.\n    \n    Args:\n        gt: List[Union[int, float]] coordinates of the ground-truth box\n        pred: List[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        IoU: float Intersection over union (0.0 <= iou <= 1.0)\n    \"\"\"\n    if form == 'coco':\n        bgt = Box(gt[0], gt[1], gt[0] + gt[2], gt[1] + gt[3])\n        bpr = Box(pred[0], pred[1], pred[0] + pred[2], pred[1] + pred[3])\n    else:\n        bgt = Box(gt[0], gt[1], gt[2], gt[3])\n        bpr = Box(pred[0], pred[1], pred[2], pred[3])\n        \n\n    overlap_area = 0.0\n    union_area = 0.0\n\n    # Calculate overlap area\n    dx = min(bgt.xmax, bpr.xmax) - max(bgt.xmin, bpr.xmin)\n    dy = min(bgt.ymax, bpr.ymax) - max(bgt.ymin, bpr.ymin)\n\n    if (dx > 0) and (dy > 0):\n        overlap_area = dx * dy\n\n    # Calculate union area\n    union_area = (\n            (bgt.xmax - bgt.xmin) * (bgt.ymax - bgt.ymin) +\n            (bpr.xmax - bpr.xmin) * (bpr.ymax - bpr.ymin) -\n            overlap_area\n    )\n\n    return overlap_area / union_area\n\n#MAP Calculation\ndef find_best_match(gts, predd, threshold=0.5, form='pascal_voc'):\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: Coordinates of the available ground-truth boxes\n        pred: Coordinates of the predicted box\n        threshold: Threshold\n        form: Format of the coordinates\n        \n    Return:\n        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    \n    for gt_idx, ggt in enumerate(gts):\n        iou = calculate_iou(ggt, predd, form=form)\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\n\ndef calculate_precision(preds_sorted, gt_boxes, threshold=0.5, form='coco'):\n    \"\"\"Calculates precision per at one threshold.\n    \n    Args:\n        preds_sorted: \n    \"\"\"\n    tp = 0\n    fp = 0\n    fn = 0\n\n    fn_boxes = []\n\n    for pred_idx, pred in enumerate(preds_sorted):\n        best_match_gt_idx = find_best_match(gt_boxes, pred, threshold=threshold, form=form)\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\n            # Remove the matched GT box\n            gt_boxes = np.delete(gt_boxes, best_match_gt_idx, axis=0)\n\n        else:\n            # No match\n            # False positive: indicates a predicted box had no associated gt box.\n            fn += 1\n            fn_boxes.append(pred)\n\n    # False negative: indicates a gt box had no associated predicted box.\n    fp = len(gt_boxes)\n    precision = tp / (tp + fp + fn)\n    return precision, fn_boxes, gt_boxes\n\n\ndef calculate_image_precision(preds_sorted, gt_boxes, thresholds=(0.5), form='coco', debug=False):\n    \n    n_threshold = len(thresholds)\n    image_precision = 0.0\n    \n    for threshold in thresholds:\n        precision_at_threshold, _, _ = calculate_precision(preds_sorted,\n                                                           gt_boxes,\n                                                           threshold=threshold,\n                                                           form=form\n                                                          )\n        if debug:\n            print(\"@{0:.2f} = {1:.4f}\".format(threshold, precision_at_threshold))\n\n        image_precision += precision_at_threshold / n_threshold\n    \n    return image_precision","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Logging Metrics and Predicted Bounding Boxes\nHere we define train and test functions that will use the W&B logging features.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"\n\ndef train(args, model, device, train_data_loader, optimizer, epoch, iteration):\n    print(\"Epoch: \", epoch)\n    \n    #Train Loop\n    for batch_idx, (images, targets) in enumerate(train_data_loader):\n        \n        #Train and calculate loss\n        model.train()\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        loss_dict = model(images, targets)\n        \n        losses = sum(loss for loss in loss_dict.values())\n        loss_value = losses.item()\n\n        optimizer.zero_grad()\n        losses.backward()\n        optimizer.step()\n        if batch_idx % args.log_interval == 0:\n            #Log the train loss and iteration\n            wandb.log({\"train_loss\": loss_value, \"iteration_train\": iteration})\n        \n        iteration += 1 #iteration increases for every batch\n        \n    \n    return iteration #returns the updated new iteration\n            ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In the test function we will also log the bounding boxes so we can see visualizations.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"#[xmin, ymin, xmax, ymax] => [x, y, width, height]\ndef convert_boxes_format(boxes):\n    boxes[:, 2] = boxes[:, 2] - boxes[:, 0]\n    boxes[:, 3] = boxes[:, 3] - boxes[:, 1]\n    return boxes\n\nclass_id_to_label = {\n    0: \"target\",\n    1: \"wheat\"\n}\n\n#Test will run as validation and log bounding boxes with confidence/prediction scores\ndef test(args, model, device, test_data_loader, epoch, iteration):\n    \n    \n    epoch_precision_score = []\n    for batch_idx, (images, targets) in enumerate(test_data_loader):\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        model.eval()\n        outputs = model(images)\n        \n        #Calculate Precision Score Per Batch\n        batch_precision_score = []\n        for i, image in enumerate(images):\n            \n            #predicted bounding boxes\n            boxes = outputs[i]['boxes'].data.cpu().numpy()\n            boxes = convert_boxes_format(boxes)\n            \n            scores = outputs[i]['scores'].data.cpu().numpy()\n            \n            #ground truth bounding boxes\n            gt_boxes = targets[i][\"boxes\"].cpu().numpy()\n            gt_boxes = convert_boxes_format(gt_boxes)\n\n            # Sort highest confidence -> lowest confidence\n            preds_sorted_idx = np.argsort(scores)[::-1]\n            preds_sorted = boxes[preds_sorted_idx]\n\n            iou_thresholds = [x for x in np.arange(0.5, 0.76, 0.05)]\n            image_precision = calculate_image_precision(preds_sorted, gt_boxes,\n                                            thresholds=iou_thresholds,\n                                            form='coco', debug=False)\n            \n            #print(\"Average Precision of image: {0:.4f}\".format(image_precision))\n            batch_precision_score.append(image_precision)\n        \n        batch_precision_score = np.mean(batch_precision_score) #average precision score for the batch\n        epoch_precision_score.append(batch_precision_score)\n        \n        if batch_idx % args.log_interval == 0:\n            #logs the precision score per batch and also the iteration\n            wandb.log({\"batch_score_validation\": batch_precision_score, \"iteration_validation\": iteration})\n        \n        #Log bounding boxes\n        if batch_idx % args.image_log_interval == 0:\n            \n            #Log 1 image with bounding boxes for this batch\n            for i, image in enumerate(images[:1]): \n\n\n                scores = outputs[i]['scores'].data.cpu().numpy().astype(np.float64)\n\n                #predicted bounding boxes\n                boxes = outputs[i]['boxes'].data.cpu().numpy().astype(np.float64)\n                predicted_boxes = []\n                for b_i, box in enumerate(boxes):\n    \n                    box_data = {\"position\" : {\n                          \"minX\" : box[0],\n                          \"maxX\" : box[2],\n                          \"minY\" : box[1],\n                          \"maxY\" : box[3] \n                        },\n                      \"class_id\" : 1,\n                      \"box_caption\" : \"wheat: (%.3f)\" % (scores[b_i]),\n                      \"domain\": \"pixel\",\n                      \"scores\" : { \"score\" : scores[b_i] }\n                    }\n                    predicted_boxes.append(box_data)\n                    \n\n                #ground truth bounding boxes\n                gt_boxes = targets[i][\"boxes\"].cpu().numpy().astype(np.float64)\n                target_boxes = [] \n                for b_i, box in enumerate(gt_boxes):\n  \n                    box_data = {\"position\" : {\n                          \"minX\" : box[0],\n                          \"maxX\" : box[2],\n                          \"minY\" : box[1],\n                          \"maxY\" : box[3] \n                        },\n                      \"class_id\" : 0,\n                      \"domain\": \"pixel\",\n                      \"box_caption\" : \"ground_truth\"\n                    }\n                    target_boxes.append(box_data)\n                \n                \n                image = image.permute(1,2,0).cpu().numpy().astype(np.float64)\n                \n                #create image object and log\n                img = wandb.Image(image, boxes = \n                                  {\"predictions\": \n                                   {\"box_data\": predicted_boxes, \n                                    \"class_labels\" : class_id_to_label},\"ground_truth\": {\"box_data\": target_boxes}})\n                \n                wandb.log({\"bounding_boxes\": img})\n                \n                \n                if(batch_precision_score > 0.3):\n                    #Log an image the model performs well on\n                    wandb.log({\"bounding_boxes\": img})\n                else:\n                    #Log an image the model performs poorly on\n                    wandb.log({\"bad_bounding_boxes\": img})\n            \n        iteration += 1\n    \n    score = np.mean(epoch_precision_score)\n    wandb.log({\"epoch_score_validation\": score, \"epoch\": epoch})\n    return iteration","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Load dataset\ntrain_dataset = WheatDataset(train_df, DIR_TRAIN, get_train_transform())\nvalid_dataset = WheatDataset(valid_df, DIR_TRAIN, get_valid_transform())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The run function is our main function that puts everything together.\n\n**Note:** We are keeping track of the iterations separately for train and test. \n\nThis will allow for easier plotting of values in your W&B dashboard.\n\nYou can set the X axis for charts to use iteration_train for displaying training loss/accuracy, or iteration_test for displaying values such as validation/test loss/accuracy.\n\nThe wandb.watch() function only needs to be called once, so in subsequent runs we can comment it out.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def run():\n    \n    #Default Hyperparameter values if no sweep is defined\n    config_default = {         \n    \"batch_size\": 16,          # input batch size for training (default: 64)\n    \"test_batch_size\": 8,    # input batch size for testing (default: 1000)\n    \"epochs\": 30,             # number of epochs to train (default: 10)\n    \"lr\": 0.005,               # learning rate (default: 0.01)\n    \"momentum\": 0.9,          # SGD momentum (default: 0.5) \n    \"no_cuda\": False,         # whether to disable CUDA training\n    \"seed\": 42,               # random seed (default: 42)\n    \"log_interval\": 1,      #how many batches to wait before logging in train/test loops\n    \"image_log_interval\": 10,\n    \"decay\": 0.0005\n    }\n    os.environ[\"WANDB_API_KEY\"] = \"1988d5611a46703042decc8a5dfafd20a130796f\"\n    wandb.init(config=config_default, entity=\"authors\", project=\"GWD-fasterRCNN\")\n    config = wandb.config\n    \n    # load a model; pre-trained on COCO\n    model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n    num_classes = 2  # wheat (1)....or not wheat (0)\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    use_cuda = not config[\"no_cuda\"] and torch.cuda.is_available()\n    device = torch.device('cuda') if use_cuda else torch.device('cpu')\n\n    # Set random seeds and deterministic pytorch for reproducibility\n    # random.seed(config.seed)       # python random seed\n    torch.manual_seed(config[\"seed\"]) # pytorch random seed\n    np.random.seed(config[\"seed\"]) # numpy random seed\n    torch.backends.cudnn.deterministic = True\n\n\n    #Create dataloaders\n    train_data_loader = DataLoader(\n        train_dataset,\n        batch_size=config[\"batch_size\"],\n        shuffle=True,\n        num_workers=4,\n        collate_fn=collate_fn\n    )\n\n    valid_data_loader = DataLoader(\n        valid_dataset,\n        batch_size=config[\"test_batch_size\"],\n        shuffle=True,\n        num_workers=4,\n        collate_fn=collate_fn\n    )\n\n\n    model.to(device)\n    params = [p for p in model.parameters() if p.requires_grad]\n    optimizer = torch.optim.SGD(params, lr=config[\"lr\"], momentum=config[\"momentum\"], weight_decay=config[\"decay\"])\n    \n    ####\n    #wandb.watch(model, log=\"all\") #this line only needs to be run once to hook W&B to your model (comment out for future runs)\n    ####\n    \n    #Keep track of train and test's iterations seperatedly (this allows for easier plotting because you can use iteration_train or iteration_test for your X axis)\n    iteration_train = 0\n    iteration_test = 0\n    for epoch in range(1, config[\"epochs\"] + 1):\n        #Runs training and returns the new training iteration counter\n        iteration_train = train(config, model, device, train_data_loader, optimizer, epoch, iteration_train)\n        #Runs testing/valiadtion and returns the new test iteration counter\n        iteration_test = test(config, model, device, valid_data_loader, epoch, iteration_test)\n        print(\"Iteration Train: \", iteration_train)\n        print(\"Iteration Test: \", iteration_test)\n\n    torch.save(model.state_dict(), 'fasterrcnn_resnet50_fpn.pth')\n    wandb.save('fasterrcnn_resnet50_fpn.pth')\n    \n    #Clear memory\n    del model\n    del train_data_loader\n    del valid_data_loader\n    gc.collect()\n    torch.cuda.empty_cache()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Run sweep\n#wandb.agent(sweep_id, run)\nrun()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Results and Analysis\nWe log three runs in total each going for 30 epochs:\n\n**1. Non-shuffled: We don't shuffle the dataset before doing a train-validation split:** \n\nhttps://app.wandb.ai/authors/GWD-fasterRCNN/runs/3h9d743s\n\n**2. Shuffled-dataloader: We only shuffle the data in the Dataloader (shuffle=True):**\n\nhttps://app.wandb.ai/authors/GWD-fasterRCNN/runs/2akilbxr\n\n**3. Shuffled-both: We shuffle the data before splitting (using train_test_split) and also shuffle the data in the Dataloader (shuffle=True):** \n\nhttps://app.wandb.ai/authors/GWD-fasterRCNN/runs/2jjqtlf1\n\n","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"\n![Screenshot_252.png](attachment:Screenshot_252.png)","attachments":{"Screenshot_252.png":{"image/png":"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"}},"execution_count":null},{"metadata":{},"cell_type":"markdown","source":"By looking at the charts produced, we can see that the \"non-shuffled\" run performs very differently and is much lower on the average validation score logged per epoch. This difference is even more staggering when the per batch validation score is logged. We see periodic dips to the 0.2 level then rising back up. The main reason behind this is the ordering of the data.\n\nBecause \"non-shuffled\" simply takes the last 674 images as validation data, there could be specific images that cause inferior performance. These could be images from a specific geographical region or due to some noise. We can find out what images the model performs poorly on by explicitly logging bad images when the calculated batch validation score is lower than 0.3 (this is done at the end of the test() function above).\n\nBelow we show some examples of bad images and good images in the \"non-shuffled\" run along with the model's predictions.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Blue boxes = ground truth labels, Red boxes = model predictions\n\n### Bounding Boxes of Good Images\n![](https://i.imgur.com/h4jKYA0.png)\n\n### Bounding Boxes of Bad Images\n![](https://i.imgur.com/5Wmoi29.png)","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"From the images above, we can see that good images are mostly on a darker surface with clearly defined wheat heads. The background is not cluttered with other vegetation. On the other hand, bad images where the model does poorly are often cluttered with a lot of vegetation intertwined with the wheat heads. We can see that it is often challenging to visually distinguish wheat heads, which may cause errors in labeling.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Benefits of Shuffling Data\n\nBy comparing the \"non-shuffled\" with the shuffled runs, we see the benefit of shuffling data. By mixing good images with bad images, it averages out the model's performance. This prevents the model from learning from a specific set of images and then being tested/validated on images from another region or with different features. At most, it may result in a few points higher in the score, and at the very least, shuffling the data gives a more representative view of the model's true capabilities during validation/testing.\n","execution_count":null}],"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"}},"nbformat":4,"nbformat_minor":4}