initiated

artifacts/model/resnet18_fruits.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9aab7287020d56634eeb010928b0b5e85e85460df6a4737f254332a9733dd19
+size 47009876

config/config.yaml

@@ -0,0 +1,3 @@
+artifacts_root: artifacts
+data_root: artifacts/data
+model_root: artifacts/model

params.yaml

@@ -0,0 +1,5 @@
+N_EPOCHS: 100
+N_CLASSES: 10
+N_FREEZE_EPOCHS: 5
+PATIENCE: 15
+MODEL_NAME: 'resnet18_fruits'

requirements.txt

@@ -0,0 +1,5 @@
+fastai==2.7.12
+numpy==1.23.5
+opencv-python==4.9.0.80
+Pillow==9.5.0
+streamlit==1.24.0

src/fruit_classifier/components/model_trainer.py

@@ -0,0 +1,69 @@
+from fastai.vision.all import *
+from fastai.vision.widgets import *
+
+from fruit_classifier.config.configuration import ConfigurationManager
+
+
+class ModelTrainer:
+
+    def __init__(self):
+        
+        config_manager = ConfigurationManager()
+        self.config = config_manager.get_training_config()
+
+    def random_seed(seed_value, use_cuda):
+        np.random.seed(seed_value) # cpu vars
+        torch.manual_seed(seed_value) # cpu  vars
+        random.seed(seed_value) # Python
+        if use_cuda: 
+            torch.cuda.manual_seed(seed_value)
+            torch.cuda.manual_seed_all(seed_value) # gpu vars
+            torch.backends.cudnn.deterministic = True  #needed
+            torch.backends.cudnn.benchmark = False
+
+    def create_dls(self):
+
+        path = self.config.training_data
+
+        fruit_db = DataBlock(
+            blocks=(ImageBlock, CategoryBlock),
+            get_items=get_image_files,
+            splitter=RandomSplitter(valid_pct=0.2),#, seed=42),
+            get_y=parent_label,
+            item_tfms=Resize(464),
+            batch_tfms=aug_transforms(size=224, min_scale=0.5)
+        )
+
+        dls = fruit_db.dataloaders(path, num_workers=0)
+
+        return dls
+    
+    def train_model(self):
+
+        self.random_seed(seed_value=13, use_cuda=True)
+
+        dls = self.create_dls()
+
+        learn = vision_learner(
+            dls, 
+            resnet18, 
+            loss_func=LabelSmoothingCrossEntropy(), 
+            metrics=accuracy, 
+            cbs=[
+                MixUp, 
+                SaveModelCallback(
+                    monitor='accuracy',
+                    fname=self.config.params_model_name
+                ),
+                EarlyStoppingCallback(
+                    monitor='accuracy', 
+                    patience=self.config.params_patience
+                )
+            ]
+        )
+
+        learn.fine_tune(self.config.params_epochs, freeze_epochs=self.config.params_n_freeze_epochs)
+
+        model = vision_learner(dls, resnet18)
+        model.load(self.config.params_model_name)
+        model.export(f'{self.config.trained_model_path}/{self.config.params_model_name}.pkl')

src/fruit_classifier/config/configuration.py

@@ -0,0 +1,50 @@
+from fruit_classifier.constants import *
+from fruit_classifier.utils.utils import read_yaml, create_directories
+from fruit_classifier.entity.entity import DataConfig, TrainingConfig
+
+
+class ConfigurationManager:
+
+    def __init__(
+        self,
+        config_filepath = CONFIG_FILE_PATH,
+        params_filepath = PARAMS_FILE_PATH):
+
+        self.config = read_yaml(config_filepath)
+        self.params = read_yaml(params_filepath)
+
+        create_directories([self.config['artifacts_root']])
+
+
+    
+    def get_data_config(self) -> DataConfig:
+        config = self.config['data_root']
+
+        create_directories([config])
+
+        data_config = DataConfig(
+            root_dir=config['data_root']
+        )
+
+        return data_config
+    
+
+    def get_training_config(self) -> TrainingConfig:
+        training = self.config['model_root']
+        params = self.params
+        training_data = self.config['data_root']
+        create_directories([
+            Path(training)
+        ])
+
+        training_config = TrainingConfig(
+            trained_model_path=Path(training),
+            training_data=Path(training_data),
+            params_epochs=params['N_EPOCHS'],
+            params_n_classes=params['N_CLASSES'],
+            params_n_freeze_epochs=params['N_FREEZE_EPOCHS'],
+            params_patience=params['PATIENCE'],
+            params_model_name=params['MODEL_NAME']
+        )
+
+        return training_config

src/fruit_classifier/constants/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+CONFIG_FILE_PATH = Path("config/config.yaml")
+PARAMS_FILE_PATH = Path("params.yaml")

src/fruit_classifier/entity/entity.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class DataConfig:
+    root_dir: Path
+
+
+@dataclass(frozen=True)
+class TrainingConfig:
+    trained_model_path: Path
+    training_data: Path
+    params_epochs: int
+    params_n_classes: int
+    params_n_freeze_epochs: int
+    params_patience: int
+    params_model_name: str

src/fruit_classifier/exception/exception.py

@@ -0,0 +1,20 @@
+import sys
+
+
+class CustomException(Exception):
+
+    def __init__(self, error_message, error_details:sys):
+        self.error_message = error_message
+        _, _, exc_tb = error_details.exc_info()
+        self.lineno = exc_tb.tb_lineno
+        self.file_name = exc_tb.tb_frame.f_code.co_filename
+
+    def __str__(self):
+        return "Error occured in python script name [{0}] line number [{1}] error message [{2}]".format(
+            self.file_name, self.lineno, str(self.error_message))
+
+if __name__ == '__main__':
+    try:
+        1 / 0
+    except Exception as e:
+        raise CustomException(e, sys)

src/fruit_classifier/logger/logger.py

@@ -0,0 +1,20 @@
+import logging
+import os
+from datetime import datetime as dt
+
+LOG_FILE = f"{dt.now().strftime('%m_%d_%Y_%H_%M_%S')}.log"
+
+log_path = os.path.join(os.getcwd(), "logs")
+
+os.makedirs(log_path, exist_ok=True)
+
+LOG_FILEPATH = os.path.join(log_path, LOG_FILE)
+
+logging.basicConfig(
+    level=logging.INFO,
+    filename=LOG_FILEPATH,
+    format="[%(asctime)s] %(lineno)d %(name)s - %(levelname)s - %(message)s"
+)
+
+if __name__ == '__main__':
+    logging.info("Log testing executed!!!")

src/fruit_classifier/pipeline/training_pipeline.py

@@ -0,0 +1,4 @@
+from fruit_classifier.components.model_trainer import ModelTrainer
+
+model_trainer = ModelTrainer()
+model_trainer.train_model()

src/fruit_classifier/utils/utils.py

@@ -0,0 +1,28 @@
+import os
+import yaml
+import sys
+
+from fruit_classifier.logger.logger import logging
+from fruit_classifier.exception.exception import CustomException
+
+
+def read_yaml(path_to_yaml):
+
+    try:
+        with open(path_to_yaml) as yaml_file:
+            content = yaml.safe_load(yaml_file)
+            logging.info(f"yaml file: {path_to_yaml} loaded successfully")
+            return content
+    except Exception as e:
+        logging.info('Error occured while reading the yaml file.')
+        raise CustomException(e, sys)
+    
+
+def create_directories(path_to_directories):
+
+    for path in path_to_directories:
+        os.makedirs(path, exist_ok=True)
+        logging.info(f"created directory at: {path}")
+
+
+