spforge 0.0.0__py3-none-any.whl

examples/__init__.py

@@ -0,0 +1,2 @@
+from .nba.data.utils import get_sub_sample_nba_data
+from .lol.data.utils import get_sub_sample_lol_data

examples/lol/data/utils.py

@@ -0,0 +1,20 @@
+import os
+from pathlib import Path
+from typing import Union
+
+import polars as pl
+import pandas as pd
+
+
+def get_sub_sample_lol_data(
+    as_pandas: bool = True, as_polars: bool = False
+) -> Union[pd.DataFrame]:
+    script_dir = Path(__file__).parent
+    file_path = os.path.join(script_dir, "subsample_lol_data.parquet")
+
+    if as_polars:
+        return pl.read_parquet(file_path)
+    elif as_pandas:
+        return pd.read_parquet(file_path)
+    else:
+        raise ValueError("Must specify either as_pandas or as_polars")

examples/lol/pipeline_transformer_example.py

@@ -0,0 +1,158 @@
+from lightgbm import LGBMRegressor
+from sklearn.linear_model import LogisticRegression
+
+from examples import get_sub_sample_lol_data
+from spforge import ColumnNames
+from spforge.cross_validator import MatchKFoldCrossValidator
+from spforge.pipeline_transformer import PipelineTransformer
+from spforge.predictor import (
+    GameTeamPredictor,
+    SklearnPredictor,
+)
+from spforge.predictor.classifier import NegativeBinomialPredictor
+from spforge.ratings import (
+    UpdateRatingGenerator,
+    RatingKnownFeatures,
+)
+from spforge.ratings.performance_generator import (
+    PerformancesGenerator,
+    Performance,
+    ColumnWeight,
+)
+from spforge.transformers import LagTransformer
+from spforge.transformers import (
+    RollingMeanTransformer,
+)
+
+column_names = ColumnNames(
+    team_id="teamname",
+    match_id="gameid",
+    start_date="date",
+    player_id="playername",
+    league="league",
+    position="position",
+)
+df = get_sub_sample_lol_data(as_pandas=True)
+df = (
+    df.loc[lambda x: x.position != "team"]
+    .assign(team_count=df.groupby("gameid")["teamname"].transform("nunique"))
+    .loc[lambda x: x.team_count == 2]
+    .assign(
+        player_count=df.groupby(["gameid", "teamname"])["playername"].transform(
+            "nunique"
+        )
+    )
+    .loc[lambda x: x.player_count == 5]
+)
+df = df.assign(team_count=df.groupby("gameid")["teamname"].transform("nunique")).loc[
+    lambda x: x.team_count == 2
+]
+
+df = df.drop_duplicates(subset=["gameid", "playername"])
+
+# Pretends the last 10 games are future games. The most will be trained on everything before that.
+most_recent_10_games = df[column_names.match_id].unique()[-10:]
+historical_df = df[~df[column_names.match_id].isin(most_recent_10_games)]
+future_df = df[df[column_names.match_id].isin(most_recent_10_games)].drop(
+    columns=["result"]
+)
+
+rating_generator_result = UpdateRatingGenerator(
+    features_out=[RatingKnownFeatures.RATING_DIFFERENCE_PROJECTED],
+    performance_column="result",
+)
+
+rating_generator_player_kills = UpdateRatingGenerator(
+    features_out=[RatingKnownFeatures.RATING_MEAN_PROJECTED],
+    performances_generator=PerformancesGenerator(
+        performances=Performance(
+            name="performance_kills",
+            weights=[
+                ColumnWeight(name="kills", weight=1),
+            ],
+        ),
+    ),
+)
+
+lag_generators = [
+    LagTransformer(
+        features=["kills", "deaths", "result"], lag_length=3, granularity=["playername"]
+    ),
+    RollingMeanTransformer(
+        features=["kills", "deaths", "result"],
+        window=20,
+        min_periods=1,
+        granularity=["playername"],
+    ),
+]
+
+transformer = PipelineTransformer(
+    column_names=column_names,
+    rating_generators=[rating_generator_result, rating_generator_player_kills],
+    lag_transformers=lag_generators,
+)
+
+historical_df = transformer.fit_transform(historical_df)
+
+game_winner_predictor = GameTeamPredictor(
+    predictor=SklearnPredictor(
+        estimator=LogisticRegression(),
+        target="result",
+        features=[RatingKnownFeatures.RATING_DIFFERENCE_PROJECTED],
+    ),
+    one_hot_encode_cat_features=True,
+    impute_missing_values=True,
+    game_id_colum=column_names.match_id,
+    team_id_column=column_names.team_id,
+)
+
+player_kills_predictor = SklearnPredictor(
+    estimator=LGBMRegressor(verbose=-100),
+    target="kills",
+    features=[game_winner_predictor.pred_column],
+    features_contain_str=["rolling_mean_kills", "lag_kills"],
+)
+
+cross_validator_game_winner = MatchKFoldCrossValidator(
+    date_column_name=column_names.start_date,
+    match_id_column_name=column_names.match_id,
+    predictor=game_winner_predictor,
+)
+
+game_winner_predictor.train(historical_df)
+historical_df = cross_validator_game_winner.generate_validation_df(
+    historical_df, column_names
+)
+
+cross_validator_player_kills = MatchKFoldCrossValidator(
+    date_column_name=column_names.start_date,
+    match_id_column_name=column_names.match_id,
+    predictor=player_kills_predictor,
+)
+
+player_kills_predictor.train(historical_df)
+print(player_kills_predictor.features)
+historical_df = cross_validator_player_kills.generate_validation_df(
+    historical_df, column_names
+)
+
+future_df = transformer.transform(future_df)
+future_df = game_winner_predictor.predict(future_df)
+future_df = player_kills_predictor.predict(future_df)
+
+probability_predictor = NegativeBinomialPredictor(
+    target="kills",
+    point_estimate_pred_column=player_kills_predictor.pred_column,
+    relative_error_predictor=SklearnPredictor(
+        estimator=LGBMRegressor(),
+        target=None,
+        features=["position"],
+        convert_cat_features_to_cat_dtype=True,
+    ),
+    max_value=15,
+)
+
+probability_predictor.train(historical_df)
+future_df = probability_predictor.predict(future_df)
+
+print(future_df.head(10))

examples/nba/cross_validation_example.py

@@ -0,0 +1,131 @@
+import polars as pl
+from sklearn.metrics import mean_absolute_error
+from lightgbm import LGBMRegressor, LGBMClassifier
+
+from examples import get_sub_sample_nba_data
+from spforge.cross_validator import MatchKFoldCrossValidator
+
+from spforge.pipeline import Pipeline
+from spforge.predictor import SklearnPredictor
+
+from spforge.data_structures import ColumnNames
+from spforge.predictor.classifier import NegativeBinomialPredictor
+from spforge.predictor.predictor import DistributionPredictor
+from spforge.scorer import SklearnScorer, OrdinalLossScorer
+from spforge.scorer import Filter, Operator
+from spforge.transformers import (
+    RollingMeanTransformer, LagTransformer,
+)
+
+df = get_sub_sample_nba_data(as_polars=True, as_pandas=False)
+# df = df.filter(pl.col('minutes')>0)
+column_names = ColumnNames(
+    team_id="team_id",
+    match_id="game_id",
+    start_date="start_date",
+    player_id="player_name",
+)
+df = df.sort(
+    [
+        column_names.start_date,
+        column_names.match_id,
+        column_names.team_id,
+        column_names.player_id,
+    ]
+)
+
+df = df.with_columns(pl.col("points").clip(0, 40).alias("points"))
+
+predictor = DistributionPredictor(
+    point_predictor=SklearnPredictor(
+        estimator=LGBMRegressor(verbose=-100, random_state=42),
+        features=["location"],
+        target="points",
+        convert_cat_features_to_cat_dtype=True,
+        pred_column="points_estimate",
+    ),
+    distribution_predictor=NegativeBinomialPredictor(
+        max_value=40, target="points", point_estimate_pred_column="points_estimate"
+    ),
+)
+
+pipeline = Pipeline(
+    lag_transformers=[
+        RollingMeanTransformer(features=["points"], window=15, granularity=["player_id"]),
+        LagTransformer(features=['points'],lag_length=3, granularity=['player_id'])
+    ],
+    predictor=predictor,
+    column_names=column_names,
+)
+
+cross_validator = MatchKFoldCrossValidator(
+    date_column_name=column_names.start_date,
+    match_id_column_name=column_names.match_id,
+    predictor=pipeline,
+)
+validation_df = cross_validator.generate_validation_df(
+    df=df, column_names=column_names, return_features=True
+)
+
+mean_absolute_scorer = SklearnScorer(
+    pred_column=predictor.point_predictor.pred_column,
+    target=predictor.target,
+    scorer_function=mean_absolute_error,
+    validation_column="is_validation",
+    filters=[Filter(column_name="minutes", value=0, operator=Operator.GREATER_THAN)],
+)
+
+mae_score = cross_validator.cross_validation_score(
+    validation_df=validation_df, scorer=mean_absolute_scorer
+)
+print(f"MAE {mae_score}")
+
+ordinal_scorer = OrdinalLossScorer(
+    pred_column=predictor.pred_column,
+    target=predictor.target,
+    validation_column="is_validation",
+    filters=[Filter(column_name="minutes", value=0, operator=Operator.GREATER_THAN)],
+)
+
+ordinal_loss_score = cross_validator.cross_validation_score(
+    validation_df=validation_df, scorer=ordinal_scorer
+)
+print(f"Ordinal Loss {ordinal_loss_score}")
+
+lgbm_classifier_predictor = SklearnPredictor(
+    estimator=LGBMClassifier(verbose=-100, random_state=42, max_depth=2),
+    features=[
+        *pipeline.lag_transformers[0].features_out,
+        "location",
+        predictor.point_predictor.pred_column,
+    ],
+    target=predictor.target,
+    pred_column="lgbm_classifier_point_estimate",
+    convert_cat_features_to_cat_dtype=True,
+    multiclass_output_as_struct=True,
+)
+
+lgbm_classifier_cross_validator = MatchKFoldCrossValidator(
+    date_column_name=column_names.start_date,
+    match_id_column_name=column_names.match_id,
+    predictor=lgbm_classifier_predictor,
+)
+
+validation_df = lgbm_classifier_cross_validator.generate_validation_df(
+    df=validation_df, column_names=column_names
+)
+
+ordinal_scorer_lgbm_classifier = OrdinalLossScorer(
+    pred_column=lgbm_classifier_predictor.pred_column,
+    target=predictor.target,
+    validation_column="is_validation",
+    filters=[Filter(column_name="minutes", value=0, operator=Operator.GREATER_THAN)],
+)
+
+
+lgbm_classifier_ordinal_loss_score = (
+    lgbm_classifier_cross_validator.cross_validation_score(
+        validation_df=validation_df, scorer=ordinal_scorer_lgbm_classifier
+    )
+)
+print(f"Ordinal Loss Lgbm Classifier {lgbm_classifier_ordinal_loss_score}")

examples/nba/data/utils.py

@@ -0,0 +1,19 @@
+import os
+from pathlib import Path
+from typing import Union
+
+import polars as pl
+import pandas as pd
+
+
+def get_sub_sample_nba_data(
+    as_pandas: bool = True, as_polars: bool = False
+) -> Union[pd.DataFrame]:
+    script_dir = Path(__file__).parent
+    file_path = os.path.join(script_dir, "game_player_subsample.parquet")
+    if as_polars:
+        return pl.read_parquet(file_path)
+    elif as_pandas:
+        return pd.read_parquet(file_path)
+    else:
+        raise ValueError("Must specify either as_pandas or as_polars")

examples/nba/game_winner_example.py

@@ -0,0 +1,94 @@
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+
+from spforge.pipeline import Pipeline
+from spforge.predictor import GameTeamPredictor, SklearnPredictor
+
+from spforge.ratings import UpdateRatingGenerator
+
+from spforge.data_structures import ColumnNames
+from spforge.ratings.rating_calculators import MatchRatingGenerator
+
+df = pd.read_parquet("data/game_player_subsample.parquet")
+
+# Defines the column names as they appear in the dataframe
+column_names = ColumnNames(
+    team_id="team_id",
+    match_id="game_id",
+    start_date="start_date",
+    player_id="player_name",
+)
+# Sorts the dataframe. The dataframe must always be sorted as below
+df = df.sort_values(
+    by=[
+        column_names.start_date,
+        column_names.match_id,
+        column_names.team_id,
+        column_names.player_id,
+    ]
+)
+
+# Drops games with less or more than 2 teams
+df = (
+    df.assign(
+        team_count=df.groupby(column_names.match_id)[column_names.team_id].transform(
+            "nunique"
+        )
+    )
+    .loc[lambda x: x.team_count == 2]
+    .drop(columns=["team_count"])
+)
+
+# Pretends the last 10 games are future games. The most will be trained on everything before that.
+most_recent_10_games = df[column_names.match_id].unique()[-10:]
+historical_df = df[~df[column_names.match_id].isin(most_recent_10_games)]
+future_df = df[df[column_names.match_id].isin(most_recent_10_games)].drop(
+    columns=["won"]
+)
+
+# Defining a simple rating-generator. It will use the "won" column to update the ratings.
+# In contrast to a typical Elo, ratings will follow players.
+
+match_rating_generator = MatchRatingGenerator(rating_change_multiplier=30)
+
+rating_generator = UpdateRatingGenerator(
+    performance_column="won", match_rating_generator=match_rating_generator
+)
+
+# Defines the predictor. A machine-learning model will be used to predict game winner on a game-team-level.
+# Mean team-ratings will be calculated (from player-level) and rating-difference between the 2 teams calculated.
+# It will also use the location of the game as a feature.
+predictor = GameTeamPredictor(
+    game_id_colum=column_names.match_id,
+    team_id_column=column_names.team_id,
+    predictor=SklearnPredictor(
+        features=["location"], target="won", estimator=LogisticRegression()
+    ),
+    one_hot_encode_cat_features=True,
+)
+
+# Pipeline is whether we define all the steps. Other transformations can take place as well.
+# However, in our simple example we only have a simple rating-generator and a predictor.
+pipeline = Pipeline(
+    rating_generators=rating_generator,
+    predictor=predictor,
+    column_names=column_names,
+)
+
+# Trains the model and returns historical predictions
+pipeline.train(df=historical_df)
+
+# Future predictions on future results
+future_predictions = pipeline.predict(df=future_df)
+
+# Grouping predictions from game-player level to game-level.
+team_grouped_predictions = future_predictions.groupby(column_names.match_id).first()[
+    [
+        column_names.start_date,
+        column_names.team_id,
+        "team_id_opponent",
+        predictor.pred_column,
+    ]
+]
+
+print(team_grouped_predictions)

spforge/__init__.py

@@ -0,0 +1,3 @@
+from .data_structures import ColumnNames
+from .pipeline import Pipeline
+from .pipeline_factory import PipelineFactory

spforge/cross_validator/__init__.py

@@ -0,0 +1,2 @@
+from ._base import CrossValidator
+from .cross_validator import MatchKFoldCrossValidator

spforge/cross_validator/_base.py

@@ -0,0 +1,47 @@
+from abc import abstractmethod, ABC
+from typing import Optional
+
+from spforge import ColumnNames
+
+from spforge.predictor._base import BasePredictor
+from spforge.scorer import BaseScorer
+
+from narwhals.typing import FrameT, IntoFrameT
+
+
+class CrossValidator(ABC):
+
+    def __init__(
+        self,
+        scorer: Optional[BaseScorer],
+        min_validation_date: str,
+        predictor: BasePredictor,
+    ):
+        self.scorer = scorer
+        self.min_validation_date = min_validation_date
+        self.predictor = predictor
+
+    @property
+    def validation_column_name(self) -> str:
+        return "is_validation"
+
+    @abstractmethod
+    def generate_validation_df(
+        self,
+        df: FrameT,
+        column_names: ColumnNames,
+        return_features: bool = False,
+        add_train_prediction: bool = False,
+    ) -> IntoFrameT:
+        pass
+
+    def cross_validation_score(
+        self, validation_df: FrameT, scorer: Optional[BaseScorer] = None
+    ) -> float:
+        if not scorer and not self.scorer:
+            raise ValueError(
+                "scorer is not defined. Either pass into constructor or as argument to method"
+            )
+
+        scorer = scorer or self.scorer
+        return scorer.score(df=validation_df)