Skip to content

baseline

baseline

Baseline heuristic models for FPL prediction.

BaselineModel 

BaselineModel(
    method: str = "rolling_mean", window: int = 5
)

Bases: BaseModel

Baseline model using simple heuristics.

Methods: - Rolling average of points - Weighted recent form - Form-based prediction

Initialize baseline model.

PARAMETER DESCRIPTION
method

Prediction method: 'rolling_mean', 'ewma', 'last_value'

TYPE: str DEFAULT: 'rolling_mean'

window

Window size for rolling calculations

TYPE: int DEFAULT: 5

Source code in fplx/models/baseline.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def __init__(self, method: str = "rolling_mean", window: int = 5):
    """
    Initialize baseline model.

    Parameters
    ----------
    method : str
        Prediction method: 'rolling_mean', 'ewma', 'last_value'
    window : int
        Window size for rolling calculations
    """
    self.method = method
    self.window = window
    self.predictions = {}

fit 

fit(X, y=None)

Fit the model (no-op for baseline).

Source code in fplx/models/baseline.py 
37
38
39
def fit(self, X, y=None):
    """Fit the model (no-op for baseline)."""
    return self

predict 

predict(X: DataFrame) -> float

Predict next gameweek points for a player.

PARAMETER DESCRIPTION
X

Player historical data

TYPE: DataFrame

RETURNS DESCRIPTION
float

Predicted points
Source code in fplx/models/baseline.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
def predict(self, X: pd.DataFrame) -> float:
    """
    Predict next gameweek points for a player.

    Parameters
    ----------
    X : pd.DataFrame
        Player historical data

    Returns
    -------
    float
        Predicted points
    """
    if X.empty or "points" not in X.columns:
        return 0.0

    points = X["points"]

    if self.method == "rolling_mean":
        return self._rolling_mean(points)
    if self.method == "ewma":
        return self._ewma(points)
    if self.method == "last_value":
        return points.iloc[-1]
    logger.warning(f"Unknown method {self.method}, using rolling_mean")
    return self._rolling_mean(points)

batch_predict 

batch_predict(
    players_data: dict[str, DataFrame],
) -> dict[str, float]

Predict for multiple players.

PARAMETER DESCRIPTION
players_data

Dictionary mapping player ID to their data

TYPE: dict[str, DataFrame]

RETURNS DESCRIPTION
dict[str, float]

Dictionary of predictions
Source code in fplx/models/baseline.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
def batch_predict(self, players_data: dict[str, pd.DataFrame]) -> dict[str, float]:
    """
    Predict for multiple players.

    Parameters
    ----------
    players_data : dict[str, pd.DataFrame]
        Dictionary mapping player ID to their data

    Returns
    -------
    dict[str, float]
        Dictionary of predictions
    """
    predictions = {}
    for player_id, data in players_data.items():
        predictions[player_id] = self.predict(data)

    self.predictions = predictions
    return predictions

FormBasedModel 

FormBasedModel(
    method: str = "rolling_mean", window: int = 5
)

Bases: BaselineModel

Enhanced baseline using form indicators.

Source code in fplx/models/baseline.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def __init__(self, method: str = "rolling_mean", window: int = 5):
    """
    Initialize baseline model.

    Parameters
    ----------
    method : str
        Prediction method: 'rolling_mean', 'ewma', 'last_value'
    window : int
        Window size for rolling calculations
    """
    self.method = method
    self.window = window
    self.predictions = {}

predict 

predict(X: DataFrame) -> float

Predict based on form with adjustments.

PARAMETER DESCRIPTION
X

Player historical data

TYPE: DataFrame

RETURNS DESCRIPTION
float

Predicted points
Source code in fplx/models/baseline.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
def predict(self, X: pd.DataFrame) -> float:
    """
    Predict based on form with adjustments.

    Parameters
    ----------
    X : pd.DataFrame
        Player historical data

    Returns
    -------
    float
        Predicted points
    """
    if X.empty:
        return 0.0

    base_prediction = super().predict(X)

    # Apply adjustments
    latest = X.iloc[-1]

    # Minutes adjustment: if playing less, reduce prediction
    if "minutes" in latest and latest["minutes"] < 60:
        base_prediction *= 0.7

    # Trend adjustment
    if "points_trend_5" in latest:
        trend = latest["points_trend_5"]
        if trend > 0.5:
            base_prediction *= 1.1  # Positive trend bonus
        elif trend < -0.5:
            base_prediction *= 0.9  # Negative trend penalty

    return max(0, base_prediction)