Skip to content

Logistic Regression

A scikit-learn logistic regression classifier serving as a baseline tabular model.

Overview

  • Type: Tabular
  • Library: scikit-learn
  • Registry name: logistic_regression
  • Class: LogisticRegressionModel

Configuration

# configs/models/logistic.yaml
model_type: logistic_regression
C: 1.0
penalty: l2
class_weight: balanced
max_iter: 1000
Parameter Default Description
C 1.0 Inverse regularization strength
penalty l2 Regularization type
class_weight balanced Adjusts weights inversely proportional to class frequencies
max_iter 1000 Maximum iterations for solver

Usage

from pitch_sequencing import get_model

model = get_model("logistic_regression", {"C": 1.0, "class_weight": "balanced"})
model.fit(X_train, y_train)

predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)

API Reference

pitch_sequencing.models.baselines.LogisticRegressionModel

Bases: BaseModel

Logistic Regression baseline for tabular pitch data.

Source code in src/pitch_sequencing/models/baselines.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class LogisticRegressionModel(BaseModel):
    """Logistic Regression baseline for tabular pitch data."""

    def __init__(self, config=None):
        config = config or {}
        self.C = config.get("C", 1.0)
        self.penalty = config.get("penalty", "l2")
        self.class_weight = config.get("class_weight", "balanced")
        self.max_iter = config.get("max_iter", 1000)
        self._model = None

    @property
    def name(self) -> str:
        return "Logistic Regression"

    @property
    def model_type(self) -> str:
        return "tabular"

    def fit(self, X_train, y_train, X_val=None, y_val=None, **kwargs):
        self._model = LogisticRegression(
            C=self.C,
            penalty=self.penalty,
            class_weight=self.class_weight,
            max_iter=self.max_iter,
            solver="lbfgs",
            multi_class="multinomial",
        )
        self._model.fit(X_train, y_train)

    def predict(self, X) -> np.ndarray:
        return self._model.predict(X)

    def predict_proba(self, X) -> np.ndarray:
        return self._model.predict_proba(X)

    def get_params(self) -> dict:
        return {"C": self.C, "penalty": self.penalty, "class_weight": self.class_weight}