uv ruff applied

Author: hamidkm9

src/linearboost/linear_boost.py

@@ -216,18 +216,17 @@ def __init__(
     ):
         if algorithm not in {"SAMME", "SAMME.R"}:
             raise ValueError("algorithm must be 'SAMME' or 'SAMME.R'")
-        
+
         super().__init__(
-            estimator=SEFR(),
-            n_estimators=n_estimators,
-            learning_rate=learning_rate
+            estimator=SEFR(), n_estimators=n_estimators, learning_rate=learning_rate
         )
         self.algorithm = algorithm
         self.scaler = scaler
         self.class_weight = class_weight
         self.loss_function = loss_function
 
     if SKLEARN_V1_6_OR_LATER:
+
         def __sklearn_tags__(self):
             tags = super().__sklearn_tags__()
             tags.input_tags.sparse = False
@@ -236,7 +235,6 @@ def __sklearn_tags__(self):
             tags.classifier_tags.poor_score = True
             return tags
 
-
     def _more_tags(self) -> dict[str, bool]:
         return {
             "binary_only": True,
@@ -306,7 +304,6 @@ def fit(self, X, y, sample_weight=None) -> Self:
                 sample_weight = sample_weight * expanded_class_weight
             else:
                 sample_weight = expanded_class_weight
-                
 
         with warnings.catch_warnings():
             if SKLEARN_V1_6_OR_LATER:
@@ -316,7 +313,7 @@ def fit(self, X, y, sample_weight=None) -> Self:
                     message=".*parameter 'algorithm' is deprecated.*",
                 )
             return super().fit(X_transformed, y, sample_weight)
-        
+
     def _samme_proba(self, estimator, n_classes, X):
         """Calculate algorithm 4, step 2, equation c) of Zhu et al [1].
 
@@ -345,7 +342,9 @@ def _boost(self, iboost, X, y, sample_weight, random_state):
             y_pred = estimator.predict(X)
 
             incorrect = y_pred != y
-            estimator_error = np.mean(np.average(incorrect, weights=sample_weight, axis=0))
+            estimator_error = np.mean(
+                np.average(incorrect, weights=sample_weight, axis=0)
+            )
 
             if estimator_error <= 0:
                 return sample_weight, 1.0, 0.0
@@ -355,20 +354,23 @@ def _boost(self, iboost, X, y, sample_weight, random_state):
                 return None, None, None
 
             # Compute SEFR-specific weight update
-            estimator_weight = self.learning_rate * np.log((1 - estimator_error) / estimator_error)
+            estimator_weight = self.learning_rate * np.log(
+                (1 - estimator_error) / estimator_error
+            )
 
             if iboost < self.n_estimators - 1:
                 sample_weight = np.exp(
-                    np.log(sample_weight) + estimator_weight * incorrect * (sample_weight > 0)
+                    np.log(sample_weight)
+                    + estimator_weight * incorrect * (sample_weight > 0)
                 )
 
             return sample_weight, estimator_weight, estimator_error
-                
+
         else:  # standard SAMME
             y_pred = estimator.predict(X)
             incorrect = y_pred != y
             estimator_error = np.mean(np.average(incorrect, weights=sample_weight))
-            
+
             if estimator_error <= 0:
                 return sample_weight, 1.0, 0.0
             if estimator_error >= 0.5:
@@ -378,17 +380,18 @@ def _boost(self, iboost, X, y, sample_weight, random_state):
                         "BaseClassifier in AdaBoostClassifier ensemble is worse than random, ensemble cannot be fit."
                     )
                 return None, None, None
-            
-            estimator_weight = (self.learning_rate * 
-                                np.log((1. - estimator_error) / max(estimator_error, 1e-10)))
-            
+
+            estimator_weight = self.learning_rate * np.log(
+                (1.0 - estimator_error) / max(estimator_error, 1e-10)
+            )
+
             sample_weight *= np.exp(estimator_weight * incorrect)
 
             # Normalize sample weights
             sample_weight /= np.sum(sample_weight)
 
             return sample_weight, estimator_weight, estimator_error
-    
+
     def decision_function(self, X):
         check_is_fitted(self)
         X_transformed = self.scaler_.transform(X)
@@ -399,7 +402,8 @@ def decision_function(self, X):
             n_classes = len(classes)
 
             pred = sum(
-                self._samme_proba(estimator, n_classes, X_transformed) for estimator in self.estimators_
+                self._samme_proba(estimator, n_classes, X_transformed)
+                for estimator in self.estimators_
             )
             pred /= self.estimator_weights_.sum()
             if n_classes == 2:
@@ -410,7 +414,7 @@ def decision_function(self, X):
         else:
             # Standard SAMME algorithm from AdaBoostClassifier (discrete)
             return super().decision_function(X_transformed)
-        
+
     def predict(self, X):
         """Predict classes for X.
 
@@ -434,4 +438,3 @@ def predict(self, X):
             return self.classes_.take(pred > 0, axis=0)
 
         return self.classes_.take(np.argmax(pred, axis=1), axis=0)
-