Upload model

config.json

@@ -21,6 +21,10 @@
     "shear": 3,
     "translate": 0.25
   },
+  "auto_map": {
+    "AutoConfig": "configuration_cetacean_classifier.CetaceanClassifierConfig",
+    "AutoModelForImageClassification": "modeling_cetacean_classifier.CetaceanClassifierModelForImageClassification"
+  },
   "batch_size": 8,
   "bbox_conf_threshold": 0.01,
   "bboxes": {

configuration_cetacean_classifier.py

@@ -7,29 +7,6 @@ class CetaceanClassifierConfig(PretrainedConfig):
 
     def __init__(
         self,
-        # block_type="bottleneck",
-        # layers: List[int] = [3, 4, 6, 3],
-        # num_classes: int = 1000,
-        # input_channels: int = 3,
-        # cardinality: int = 1,
-        # base_width: int = 64,
-        # stem_width: int = 64,
-        # stem_type: str = "",
-        # avg_down: bool = False,
         **kwargs,
     ):
-        # if block_type not in ["basic", "bottleneck"]:
-        #     raise ValueError(f"`block_type` must be 'basic' or bottleneck', got {block_type}.")
-        # if stem_type not in ["", "deep", "deep-tiered"]:
-        #     raise ValueError(f"`stem_type` must be '', 'deep' or 'deep-tiered', got {stem_type}.")
-
-        # self.block_type = block_type
-        # self.layers = layers
-        # self.num_classes = num_classes
-        # self.input_channels = input_channels
-        # self.cardinality = cardinality
-        # self.base_width = base_width
-        # self.stem_width = stem_width
-        # self.stem_type = stem_type
-        # self.avg_down = avg_down
         super().__init__(**kwargs)

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7513de376ac126563e7785aabedcee668ce9c9b3d20663f49e66645f480a416c
+oid sha256:7c9afc61a269bf406f5b23389c57e4efe365eb4b67aa62730b731916fb62b6f0
 size 296028464

modeling_cetacean_classifier.py

@@ -44,7 +44,12 @@ class CetaceanClassifierModelForImageClassification(PreTrainedModel):
 
     def __init__(self, config):
         super().__init__(config)
-        self.model = SphereClassifier.load_from_checkpoint("cetacean_classifier/last.ckpt")
+
+        self.model = SphereClassifier(cfg=config.to_dict())
+
+        # load_from_checkpoint("cetacean_classifier/last.ckpt")
+        # self.model = SphereClassifier.load_from_checkpoint("cetacean_classifier/last.ckpt")
+
         self.model.eval()
 
     def preprocess_image(self, img: Image) -> torch.Tensor:

train.py

@@ -1,20 +1,9 @@
-# import argparse
-# import os
-# import warnings
 from typing import Dict, List, Optional, Tuple
 
 import numpy as np
-# import optuna
-# import pandas as pd
 import timm
 import torch
-# import wandb
-# from optuna.integration import PyTorchLightningPruningCallback
 from pytorch_lightning import LightningDataModule, LightningModule, Trainer
-# from pytorch_lightning import loggers as pl_loggers
-# from pytorch_lightning.callbacks import LearningRateMonitor, ModelCheckpoint
-# from sklearn.model_selection import StratifiedKFold
-# from torch.utils.data import ConcatDataset, DataLoader
 
 from .config import Config, load_config
 # from .dataset import WhaleDataset, load_df
@@ -22,94 +11,19 @@ from .metric_learning import ArcFaceLossAdaptiveMargin, ArcMarginProductSubcente
 from .utils import WarmupCosineLambda, map_dict, topk_average_precision
 
 
-# def parse():
-#     parser = argparse.ArgumentParser(description="Training for HappyWhale")
-#     parser.add_argument("--out_base_dir", default="result")
-#     parser.add_argument("--in_base_dir", default="input")
-#     parser.add_argument("--exp_name", default="tmp")
-#     parser.add_argument("--load_snapshot", action="store_true")
-#     parser.add_argument("--save_checkpoint", action="store_true")
-#     parser.add_argument("--wandb_logger", action="store_true")
-#     parser.add_argument("--config_path", default="config/debug.yaml")
-#     return parser.parse_args()
-
-
-# class WhaleDataModule(LightningDataModule):
-#     def __init__(
-#         self,
-#         df: pd.DataFrame,
-#         cfg: Config,
-#         image_dir: str,
-#         val_bbox_name: str,
-#         fold: int,
-#         additional_dataset: WhaleDataset = None,
-#     ):
-#         super().__init__()
-#         self.cfg = cfg
-#         self.image_dir = image_dir
-#         self.val_bbox_name = val_bbox_name
-#         self.additional_dataset = additional_dataset
-#         if cfg.n_data != -1:
-#             df = df.iloc[: cfg.n_data]
-#         self.all_df = df
-#         if fold == -1:
-#             self.train_df = df
-#         else:
-#             skf = StratifiedKFold(n_splits=cfg.n_splits, shuffle=True, random_state=0)
-#             train_idx, val_idx = list(skf.split(df, df.individual_id))[fold]
-#             self.train_df = df.iloc[train_idx].copy()
-#             self.val_df = df.iloc[val_idx].copy()
-#             # relabel ids not included in training data as "new individual"
-#             new_mask = ~self.val_df.individual_id.isin(self.train_df.individual_id)
-#             self.val_df.individual_id.mask(new_mask, cfg.num_classes, inplace=True)
-#             print(f"new: {(self.val_df.individual_id == cfg.num_classes).sum()} / {len(self.val_df)}")
-
-#     def get_dataset(self, df, data_aug):
-#         return WhaleDataset(df, self.cfg, self.image_dir, self.val_bbox_name, data_aug)
-
-#     def train_dataloader(self):
-#         dataset = self.get_dataset(self.train_df, True)
-#         if self.additional_dataset is not None:
-#             dataset = ConcatDataset([dataset, self.additional_dataset])
-#         return DataLoader(
-#             dataset,
-#             batch_size=self.cfg.batch_size,
-#             shuffle=True,
-#             num_workers=2,
-#             pin_memory=True,
-#             drop_last=True,
-#         )
-
-#     def val_dataloader(self):
-#         if self.cfg.n_splits == -1:
-#             return None
-#         return DataLoader(
-#             self.get_dataset(self.val_df, False),
-#             batch_size=self.cfg.batch_size,
-#             shuffle=False,
-#             num_workers=2,
-#             pin_memory=True,
-#         )
-
-#     def all_dataloader(self):
-#         return DataLoader(
-#             self.get_dataset(self.all_df, False),
-#             batch_size=self.cfg.batch_size,
-#             shuffle=False,
-#             num_workers=2,
-#             pin_memory=True,
-#         )
-
-
 class SphereClassifier(LightningModule):
     def __init__(self, cfg: dict, id_class_nums=None, species_class_nums=None):
         super().__init__()
+        # import pdb; pdb.set_trace()
         if not isinstance(cfg, Config):
             cfg = Config(cfg)
         self.save_hyperparameters(cfg, ignore=["id_class_nums", "species_class_nums"])
         self.test_results_fp = None
 
-        print(cfg.model_name)
+        # import json
+        # cfg_json = json.dumps(cfg)
+        # with open("config_extracted.json", "w") as file:
+        #     file.write(cfg_json)
 
         # NN architecture
         self.backbone = timm.create_model(
@@ -234,85 +148,3 @@ class SphereClassifier(LightningModule):
                     result = torch.cat([x[key] for x in outputs], dim=0)
                 epoch_results[key] = result.detach().cpu().numpy()
             np.savez_compressed(self.test_results_fp, **epoch_results)
-
-
-# def train(
-#     df: pd.DataFrame,
-#     args: argparse.Namespace,
-#     cfg: Config,
-#     fold: int,
-#     do_inference: bool = False,
-#     additional_dataset: WhaleDataset = None,
-#     optuna_trial: Optional[optuna.Trial] = None,
-# ) -> Optional[float]:
-#     out_dir = f"{args.out_base_dir}/{args.exp_name}/{fold}"
-#     id_class_nums = df.individual_id.value_counts().sort_index().values
-#     species_class_nums = df.species.value_counts().sort_index().values
-#     model = SphereClassifier(cfg, id_class_nums=id_class_nums, species_class_nums=species_class_nums)
-#     data_module = WhaleDataModule(
-#         df, cfg, f"{args.in_base_dir}/train_images", cfg.val_bbox, fold, additional_dataset=additional_dataset
-#     )
-#     loggers = [pl_loggers.CSVLogger(out_dir)]
-#     if args.wandb_logger:
-#         loggers.append(
-#             pl_loggers.WandbLogger(
-#                 project="kaggle-happywhale", group=args.exp_name, name=f"{args.exp_name}/{fold}", save_dir=out_dir
-#             )
-#         )
-#     callbacks = [LearningRateMonitor("epoch")]
-#     if optuna_trial is not None:
-#         callbacks.append(PyTorchLightningPruningCallback(optuna_trial, "val/mapNone"))
-#     if args.save_checkpoint:
-#         callbacks.append(ModelCheckpoint(out_dir, save_last=True, save_top_k=0))
-#     trainer = Trainer(
-#         gpus=torch.cuda.device_count(),
-#         max_epochs=cfg["max_epochs"],
-#         logger=loggers,
-#         callbacks=callbacks,
-#         checkpoint_callback=args.save_checkpoint,
-#         precision=16,
-#         sync_batchnorm=True,
-#     )
-#     ckpt_path = f"{out_dir}/last.ckpt"
-#     if not os.path.exists(ckpt_path) or not args.load_snapshot:
-#         ckpt_path = None
-#     trainer.fit(model, ckpt_path=ckpt_path, datamodule=data_module)
-#     if do_inference:
-#         for test_bbox in cfg.test_bboxes:
-#             # all train data
-#             model.test_results_fp = f"{out_dir}/train_{test_bbox}_results.npz"
-#             trainer.test(model, data_module.all_dataloader())
-#             # test data
-#             model.test_results_fp = f"{out_dir}/test_{test_bbox}_results.npz"
-#             df_test = load_df(args.in_base_dir, cfg, "sample_submission.csv", False)
-#             test_data_module = WhaleDataModule(df_test, cfg, f"{args.in_base_dir}/test_images", test_bbox, -1)
-#             trainer.test(model, test_data_module.all_dataloader())
-
-#     if args.wandb_logger:
-#         wandb.finish()
-#     if optuna_trial is not None:
-#         return trainer.callback_metrics["val/mapNone"].item()
-#     else:
-#         return None
-
-
-# def main():
-#     args = parse()
-#     warnings.filterwarnings("ignore", ".*does not have many workers.*")
-#     cfg = load_config(args.config_path, "config/default.yaml")
-#     print(cfg)
-#     df = load_df(args.in_base_dir, cfg, "train.csv", True)
-#     pseudo_dataset = None
-#     if cfg.pseudo_label is not None:
-#         pseudo_df = load_df(args.in_base_dir, cfg, cfg.pseudo_label, False)
-#         pseudo_dataset = WhaleDataset(
-#             pseudo_df[pseudo_df.conf > cfg.pseudo_conf_threshold], cfg, f"{args.in_base_dir}/test_images", "", True
-#         )
-#     if cfg["n_splits"] == -1:
-#         train(df, args, cfg, -1, do_inference=True, additional_dataset=pseudo_dataset)
-#     else:
-#         train(df, args, cfg, 0, do_inference=True, additional_dataset=pseudo_dataset)
-
-
-# if __name__ == "__main__":
-#     main()