Upload 3 files

training/train_model_legacy.py

@@ -0,0 +1,193 @@
+import numpy as np
+import pandas as pd
+import nltk, string, logging, pickle
+import matplotlib.pyplot as plt
+import seaborn as sns
+from collections import Counter
+from nltk.corpus import stopwords
+from nltk.stem.porter import PorterStemmer
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, confusion_matrix, precision_score
+from sklearn.ensemble import VotingClassifier
+from sklearn.svm import SVC
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.ensemble import ExtraTreesClassifier
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def transform_text(text):
+    ps = PorterStemmer()
+    text = text.lower()
+    text = nltk.word_tokenize(text)
+    
+    y = []
+    for i in text:
+        if i.isalnum():
+            y.append(i)
+    
+    text = y[:]
+    y.clear()
+    
+    for i in text:
+        if i not in stopwords.words('english') and i not in string.punctuation:
+            y.append(i)
+    
+    text = y[:]
+    y.clear()
+    
+    for i in text:
+        y.append(ps.stem(i))
+    
+    return " ".join(y)
+
+def plot_dataset_insights(df):
+    plt.figure(figsize=(15, 5))
+    
+    plt.subplot(131)
+    sns.histplot(data=df, x='num_characters', hue='target', bins=50)
+    plt.title('Message Length Distribution')
+    
+    plt.subplot(132)
+    df['target'].value_counts().plot(kind='bar')
+    plt.title('Class Distribution')
+    
+    plt.subplot(133)
+    sns.boxplot(data=df, x='target', y='num_words')
+    plt.title('Word Count by Class')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/dataset_insights.png')
+    plt.close()
+
+def plot_word_clouds(df):
+    from wordcloud import WordCloud
+    plt.figure(figsize=(15, 5))
+    
+    # Map text labels to numeric
+    df['target_num'] = df['target'].map({'ham': 0, 'spam': 1})
+    
+    for idx, label in enumerate(['ham', 'spam']):
+        # Get text for current label
+        text = ' '.join(df[df['target'] == label]['transformed_text'])
+        
+        if not text.strip():
+            logger.warning(f"No text found for label: {label}")
+            continue
+            
+        try:
+            wordcloud = WordCloud(width=800, height=400).generate(text)
+            plt.subplot(1, 2, idx+1)
+            plt.imshow(wordcloud)
+            plt.axis('off')
+            plt.title(f'Word Cloud - {label.upper()}')
+        except Exception as e:
+            logger.error(f"Error generating wordcloud for {label}: {e}")
+    
+    plt.savefig('./graphs/wordclouds.png')
+    plt.close()
+
+def plot_performance_metrics(y_test, y_pred, model):
+    plt.figure(figsize=(15, 5))
+    
+    plt.subplot(131)
+    cm = confusion_matrix(y_test, y_pred)
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+    plt.title('Confusion Matrix')
+    
+    plt.subplot(132)
+    performance_df = pd.DataFrame({
+        'Metric': ['Accuracy', 'Precision'],
+        'Score': [accuracy_score(y_test, y_pred), precision_score(y_test, y_pred)]
+    })
+    sns.barplot(x='Metric', y='Score', data=performance_df)
+    plt.title('Model Performance')
+    
+    plt.subplot(133)
+    etc = model.named_estimators_['et']
+    importances = pd.Series(etc.feature_importances_)
+    importances.nlargest(10).plot(kind='bar')
+    plt.title('Top 10 Important Features')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/performance_metrics.png')
+    plt.close()
+
+def save_metrics(metrics):
+    with open('./models/metrics.txt', 'w') as f:
+        for metric, value in metrics.items():
+            f.write(f"{metric}: {value:.4f}\n")
+
+def main():
+    try:
+        # Load and preprocess data
+        logger.info("Loading data...")
+        df = pd.read_csv('./data/spam.csv', encoding='latin-1')
+        df = df.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis=1)
+        df = df.rename(columns={'v1': 'target', 'v2': 'text'})
+        
+        logger.info(f"Target value counts:\n{df['target'].value_counts()}")
+        
+        # Add numerical features
+        df['num_characters'] = df['text'].apply(len)
+        df['num_words'] = df['text'].apply(lambda x: len(nltk.word_tokenize(x)))
+        df['num_sentences'] = df['text'].apply(lambda x: len(nltk.sent_tokenize(x)))
+        
+        logger.info("Transforming text...")
+        df['transformed_text'] = df['text'].apply(transform_text)
+        
+        # Verify transformed text
+        logger.info(f"Sample transformed text:\n{df['transformed_text'].head()}")
+        
+        logger.info("Generating visualizations...")
+        plot_dataset_insights(df)
+        plot_word_clouds(df)
+        
+        # Text vectorization
+        tfidf = TfidfVectorizer(max_features=3000)
+        X = tfidf.fit_transform(df['transformed_text']).toarray()
+        # Convert target to numeric for model
+        y = (df['target'] == 'spam').astype(int)
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2)
+        
+        # Create ensemble
+        logger.info("Training model...")
+        svc = SVC(kernel='sigmoid', gamma=1.0, probability=True)
+        mnb = MultinomialNB()
+        etc = ExtraTreesClassifier(n_estimators=50, random_state=2)
+        
+        voting = VotingClassifier([('svm', svc), ('nb', mnb), ('et', etc)], voting='soft')
+        voting.fit(X_train, y_train)
+        
+        y_pred = voting.predict(X_test)
+        
+        metrics = {
+            "Accuracy": accuracy_score(y_test, y_pred),
+            "Precision": precision_score(y_test, y_pred)
+        }
+        
+        save_metrics(metrics)
+        for metric, value in metrics.items():
+            logger.info(f"{metric}: {value:.4f}")
+        
+        plot_performance_metrics(y_test, y_pred, voting)
+        
+        logger.info("Saving models...")
+        pickle.dump(tfidf, open('./models/vectorizer.pkl', 'wb'))
+        pickle.dump(voting, open('./models/model.pkl', 'wb'))
+        
+        logger.info("Training completed successfully")
+        
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        raise
+
+if __name__ == "__main__":
+    try:
+        nltk.download('punkt')
+        nltk.download('stopwords')
+        main()
+    except Exception as e:
+        print(f"Fatal error: {e}")

training/train_model_lite.py

@@ -0,0 +1,212 @@
+import numpy as np
+import pandas as pd
+import nltk, string, logging, pickle
+import matplotlib.pyplot as plt
+import seaborn as sns
+from collections import Counter
+from nltk.corpus import stopwords
+from sklearn.metrics import confusion_matrix, classification_report
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.svm import SVC
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.ensemble import ExtraTreesClassifier
+from sklearn.model_selection import cross_val_score, GridSearchCV
+from sklearn.ensemble import VotingClassifier
+from sklearn.metrics import accuracy_score, precision_score, f1_score
+nltk.download('punkt') 
+nltk.download('wordnet')
+nltk.download('stopwords')
+nltk.download('punkt_tab')
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Download required NLTK data
+try:
+    nltk.download('punkt')
+    nltk.download('wordnet')
+    nltk.download('stopwords')
+except Exception as e:
+    logger.error(f"Failed to download NLTK data: {e}")
+
+def improved_transform_text(text):
+    try:
+        from nltk.stem import WordNetLemmatizer
+        lemmatizer = WordNetLemmatizer()
+        
+        text = str(text).lower()
+        words = nltk.word_tokenize(text)
+        
+        words = [lemmatizer.lemmatize(word) for word in words 
+                if word.isalnum() and 
+                word not in stopwords.words('english') and 
+                word not in string.punctuation]
+        
+        return " ".join(words)
+    except Exception as e:
+        logger.error(f"Error in text transformation: {e}")
+        return text
+
+def extract_features(df):
+    try:
+        df['text_length'] = df['text'].str.len()
+        df['word_count'] = df['text'].str.split().str.len()
+        df['unique_word_count'] = df['text'].apply(lambda x: len(set(str(x).split())))
+        df['uppercase_count'] = df['text'].apply(lambda x: sum(1 for c in str(x) if c.isupper()))
+        df['special_char_count'] = df['text'].apply(lambda x: sum(not c.isalnum() for c in str(x)))
+        return df
+    except Exception as e:
+        logger.error(f"Error in feature extraction: {e}")
+        return df
+
+def create_optimized_ensemble():
+    try:
+        svc = SVC(kernel='rbf', C=10, gamma='auto', probability=True, random_state=42)
+        mnb = MultinomialNB(alpha=0.1)
+        etc = ExtraTreesClassifier(n_estimators=200, max_depth=None, 
+                                 min_samples_split=2, random_state=42)
+        
+        estimators = [('svc', svc), ('mnb', mnb), ('etc', etc)]
+        voting_clf = VotingClassifier(estimators=estimators, 
+                                    voting='soft', 
+                                    weights=[2,1,2])
+        return voting_clf
+    except Exception as e:
+        logger.error(f"Error creating ensemble: {e}")
+        raise
+
+def plot_dataset_insights(df):
+    plt.figure(figsize=(15, 5))
+    
+    # Message length distribution
+    plt.subplot(131)
+    sns.histplot(data=df, x='text_length', hue='target', bins=50)
+    plt.title('Message Length Distribution')
+    
+    # Class distribution
+    plt.subplot(132)
+    df['target'].value_counts().plot(kind='bar')
+    plt.title('Class Distribution')
+    
+    # Word count distribution
+    plt.subplot(133)
+    sns.boxplot(data=df, x='target', y='word_count')
+    plt.title('Word Count by Class')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/dataset_insights.png')
+    plt.close()
+
+def plot_word_clouds(df):
+    from wordcloud import WordCloud
+    
+    plt.figure(figsize=(15, 5))
+    
+    for idx, label in enumerate(['ham', 'spam']):
+        text = ' '.join(df[df['target'] == label]['transformed_text'])
+        wordcloud = WordCloud(width=800, height=400).generate(text)
+        
+        plt.subplot(1, 2, idx+1)
+        plt.imshow(wordcloud)
+        plt.axis('off')
+        plt.title(f'Word Cloud - {label.upper()}')
+    
+    plt.savefig('./graphs/wordclouds.png')
+    plt.close()
+
+def plot_performance_metrics(y_test, y_pred, model):
+    # Confusion Matrix
+    plt.figure(figsize=(15, 5))
+    
+    plt.subplot(131)
+    cm = confusion_matrix(y_test, y_pred)
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+    plt.title('Confusion Matrix')
+    
+    # Classification Report Visualization
+    plt.subplot(132)
+    report = classification_report(y_test, y_pred, output_dict=True)
+    sns.heatmap(pd.DataFrame(report).iloc[:-1, :].T, annot=True, cmap='RdYlGn')
+    plt.title('Classification Report')
+    
+    # Feature Importance (for ExtraTreesClassifier)
+    plt.subplot(133)
+    etc = model.named_estimators_['etc']
+    importances = pd.Series(etc.feature_importances_)
+    importances.nlargest(10).plot(kind='bar')
+    plt.title('Top 10 Important Features')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/performance_metrics.png')
+    plt.close()
+
+def save_metrics(metrics):
+    with open('./models/metrics.txt', 'w') as f:
+        for metric, value in metrics.items():
+            f.write(f"{metric}: {value:.4f}\n")
+    
+def main():
+    try:
+        # Load and preprocess data
+        df = pd.read_csv('./data/spam.csv', encoding='latin-1')
+        df = df.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis=1, errors='ignore')
+        df = df.rename(columns={'v1': 'target', 'v2': 'text'})
+        
+        logger.info("Preprocessing text...")
+        df['transformed_text'] = df['text'].apply(improved_transform_text)
+        df = extract_features(df)
+        
+        logger.info("Generating dataset insights...")
+        plot_dataset_insights(df)
+        plot_word_clouds(df)
+        
+        # Vectorization with optimized parameters
+        tfidf = TfidfVectorizer(
+            max_features=5000,
+            ngram_range=(1,3),
+            min_df=2,
+            max_df=0.95
+        )
+        
+        X = tfidf.fit_transform(df['transformed_text'])
+        y = (df['target'] == 'spam').astype(int)
+        
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42, stratify=y
+        )
+        
+        logger.info("Training model...")
+        model = create_optimized_ensemble()
+        model.fit(X_train, y_train)
+        
+        y_pred = model.predict(X_test)
+        
+        metrics = {
+            "Accuracy": accuracy_score(y_test, y_pred),
+            "Precision": precision_score(y_test, y_pred),
+            "F1": f1_score(y_test, y_pred)
+        }
+        
+        # Save metrics to file
+        save_metrics(metrics)
+        
+        for metric, value in metrics.items():
+            logger.info(f"{metric}: {value:.4f}")
+        
+        plot_performance_metrics(y_test, y_pred, model)
+        
+        with open('./models/vectorizer_optimized.pkl', 'wb') as f:
+            pickle.dump(tfidf, f)
+        with open('./models/model_optimized.pkl', 'wb') as f:
+            pickle.dump(model, f)
+            
+        logger.info(f"Training completed. Metrics:\n{metrics}")
+        
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

training/train_model_mbo.py

@@ -0,0 +1,265 @@
+import numpy as np
+import pandas as pd
+import nltk, string, logging, pickle, torch
+import matplotlib.pyplot as plt
+import seaborn as sns
+from collections import Counter
+from nltk.corpus import stopwords
+from sklearn.metrics import confusion_matrix, classification_report
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.svm import SVC
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.ensemble import ExtraTreesClassifier, VotingClassifier
+from sklearn.metrics import accuracy_score, precision_score, f1_score
+from torch.cuda import is_available as cuda_available
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class MonarchButterflyOptimizer:
+    def __init__(self, bounds, n_butterflies=20, p_period=1.2, migration_ratio=0.85, max_iter=30, use_gpu=False):
+        self.bounds = bounds
+        self.n_butterflies = n_butterflies
+        self.p_period = p_period
+        self.migration_ratio = migration_ratio
+        self.max_iter = max_iter
+        self.best_solution = None
+        self.best_fitness = float('-inf')
+        
+        # GPU setup
+        self.use_gpu = use_gpu and cuda_available()
+        self.device = torch.device('cuda' if self.use_gpu else 'cpu')
+        logger.info(f"Using device: {self.device}")
+
+    def initialize(self):
+        try:
+            population = []
+            for _ in range(self.n_butterflies):
+                butterfly = {}
+                for param, (low, high) in self.bounds.items():
+                    if isinstance(low, int) and isinstance(high, int):
+                        butterfly[param] = int(torch.randint(low, high+1, (1,), device=self.device).item())
+                    else:
+                        butterfly[param] = float(torch.rand(1, device=self.device).item() * (high - low) + low)
+                population.append(butterfly)
+            return population
+        except RuntimeError as e:
+            logger.error(f"CUDA error during initialization: {e}")
+            self.device = torch.device('cpu')
+            logger.info("Falling back to CPU")
+            return self.initialize()
+
+    def migration(self, population):
+        try:
+            new_population = []
+            migration_tensor = torch.rand(len(population), device=self.device)
+            
+            for idx, butterfly in enumerate(population):
+                if migration_tensor[idx].item() < self.migration_ratio:
+                    new_butterfly = {}
+                    for param in butterfly:
+                        r = torch.rand(1, device=self.device).item()
+                        new_val = butterfly[param] + self.p_period * r * (self.best_solution[param] - butterfly[param])
+                        new_butterfly[param] = self.clip(new_val, param)
+                    new_population.append(new_butterfly)
+                else:
+                    new_population.append(butterfly.copy())
+            return new_population
+        except RuntimeError as e:
+            logger.error(f"CUDA error during migration: {e}")
+            self.device = torch.device('cpu')
+            logger.info("Falling back to CPU")
+            return self.migration(population)
+    
+    def clip(self, value, param):
+        low, high = self.bounds[param]
+        if isinstance(low, int) and isinstance(high, int):
+            return int(np.clip(value, low, high))
+        return np.clip(value, low, high)
+    
+    def optimize(self, fitness_func):
+        population = self.initialize()
+        
+        for _ in range(self.max_iter):
+            for butterfly in population:
+                fitness = fitness_func(butterfly)
+                if fitness > self.best_fitness:
+                    self.best_fitness = fitness
+                    self.best_solution = butterfly.copy()
+            
+            population = self.migration(population)
+        
+        return self.best_solution, self.best_fitness
+    
+def plot_dataset_insights(df):
+    plt.figure(figsize=(15, 5))
+    
+    plt.subplot(131)
+    sns.histplot(data=df, x='feature_length', hue='target', bins=50)
+    plt.title('Message Length Distribution')
+    
+    plt.subplot(132)
+    df['target'].value_counts().plot(kind='bar')
+    plt.title('Class Distribution')
+    
+    plt.subplot(133)
+    sns.boxplot(data=df, x='target', y='word_count')
+    plt.title('Word Count by Class')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/dataset_insights.png')
+    plt.close()
+
+def plot_word_clouds(df):
+    from wordcloud import WordCloud
+    plt.figure(figsize=(15, 5))
+    
+    for idx, label in enumerate(['ham', 'spam']):
+        text = ' '.join(df[df['target'] == label]['transformed_text'])
+        wordcloud = WordCloud(width=800, height=400).generate(text)
+        
+        plt.subplot(1, 2, idx+1)
+        plt.imshow(wordcloud)
+        plt.axis('off')
+        plt.title(f'Word Cloud - {label.upper()}')
+    
+    plt.savefig('./graphs/wordclouds.png')
+    plt.close()
+
+def plot_performance_metrics(y_test, y_pred, model):
+    plt.figure(figsize=(15, 5))
+    
+    plt.subplot(131)
+    cm = confusion_matrix(y_test, y_pred)
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+    plt.title('Confusion Matrix')
+    
+    plt.subplot(132)
+    report = classification_report(y_test, y_pred, output_dict=True)
+    sns.heatmap(pd.DataFrame(report).iloc[:-1, :].T, annot=True, cmap='RdYlGn')
+    plt.title('Classification Report')
+    
+    plt.subplot(133)
+    etc = model.named_estimators_['etc']
+    importances = pd.Series(etc.feature_importances_)
+    importances.nlargest(10).plot(kind='bar')
+    plt.title('Top 10 Important Features')
+    
+    plt.tight_layout()
+    plt.savefig('./graphs/performance_metrics.png')
+    plt.close()
+
+def save_metrics(metrics):
+    with open('./models/metrics.txt', 'w') as f:
+        for metric, value in metrics.items():
+            f.write(f"{metric}: {value:.4f}\n")
+
+def create_optimized_ensemble(X_train, y_train, mbo_params):
+    param_bounds = {
+        'svc_C': (0.1, 20.0),
+        'svc_gamma': (0.001, 1.0),
+        'mnb_alpha': (0.1, 2.0),
+        'etc_n_estimators': (100, 300),
+        'w1': (0, 5),
+        'w2': (0, 5),
+        'w3': (0, 5)
+    }
+    
+    mbo = MonarchButterflyOptimizer(
+        param_bounds,
+        n_butterflies=int(mbo_params.get('n_butterflies', 20)),
+        p_period=float(mbo_params.get('p_period', 1.2)),
+        migration_ratio=float(mbo_params.get('migration_ratio', 0.85)),
+        max_iter=int(mbo_params.get('max_iter', 30)),
+        use_gpu=bool(mbo_params.get('use_gpu', False))
+    )
+    
+    def fitness_function(params):
+        svc = SVC(kernel='rbf', C=params['svc_C'], 
+                  gamma=params['svc_gamma'], probability=True)
+        mnb = MultinomialNB(alpha=params['mnb_alpha'])
+        etc = ExtraTreesClassifier(n_estimators=int(params['etc_n_estimators']))
+        
+        estimators = [('svc', svc), ('mnb', mnb), ('etc', etc)]
+        weights = [params['w1'], params['w2'], params['w3']]
+        
+        clf = VotingClassifier(estimators=estimators, voting='soft', weights=weights)
+        scores = cross_val_score(clf, X_train, y_train, cv=5)
+        return np.mean(scores)
+    
+    # Initialize and run MBO
+    mbo = MonarchButterflyOptimizer(param_bounds)
+    best_params, _ = mbo.optimize(fitness_function)
+    # Create final model with optimized parameters
+    svc = SVC(kernel='rbf', C=best_params['svc_C'], 
+              gamma=best_params['svc_gamma'], probability=True)
+    mnb = MultinomialNB(alpha=best_params['mnb_alpha'])
+    etc = ExtraTreesClassifier(n_estimators=int(best_params['etc_n_estimators']))
+    
+    estimators = [('svc', svc), ('mnb', mnb), ('etc', etc)]
+    weights = [best_params['w1'], best_params['w2'], best_params['w3']]
+    
+    return VotingClassifier(estimators=estimators, voting='soft', weights=weights)
+
+def main(mbo_params=None):
+    try:
+        logger.info("Loading data...")
+        # Load and preprocess data
+        df = pd.read_csv('./data/spam.csv', encoding='latin-1')
+        df = df.drop(['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'], axis=1)
+        df = df.rename(columns={'v1': 'target', 'v2': 'text'})
+        
+        logger.info("Preprocessing text...")
+        df['transformed_text'] = df['text'].apply(lambda x: x.lower().translate(str.maketrans('', '', string.punctuation)))
+        df['word_count'] = df['transformed_text'].str.split().str.len()
+        df['feature_length'] = df['transformed_text'].apply(len)
+        
+        logger.info("Generating visualizations...")
+        plot_dataset_insights(df)
+        plot_word_clouds(df)
+        
+        tfidf = TfidfVectorizer(max_features=5000, ngram_range=(1,3))
+        X = tfidf.fit_transform(df['transformed_text'])
+        y = (df['target'] == 'spam').astype(int)
+        
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42, stratify=y
+        )
+        
+        logger.info("Training model with MBO...")
+        if mbo_params and mbo_params.get('use_gpu'):
+            logger.info("GPU acceleration enabled")
+        model = create_optimized_ensemble(X_train, y_train, mbo_params or {})
+        
+        model.fit(X_train, y_train)
+        
+        y_pred = model.predict(X_test)
+        
+        metrics = {
+            "Accuracy": accuracy_score(y_test, y_pred),
+            "Precision": precision_score(y_test, y_pred),
+            "F1": f1_score(y_test, y_pred)
+        }
+        
+        save_metrics(metrics)
+        for metric, value in metrics.items():
+            logger.info(f"{metric}: {value:.4f}")
+            
+        plot_performance_metrics(y_test, y_pred, model)
+        
+        logger.info("Saving models...")
+        with open('./models/vectorizer_mbo.pkl', 'wb') as f:
+            pickle.dump(tfidf, f)
+        with open('./models/model_mbo.pkl', 'wb') as f:
+            pickle.dump(model, f)
+            
+        logger.info("MBO optimization completed successfully")
+        
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()