| Name | xgrove JSON |
| Version |
1.0
JSON |
| download |
| home_page | None |
| Summary | creating and calculating groves of tree models |
| upload_time | 2024-12-08 11:16:42 |
| maintainer | None |
| docs_url | None |
| author | Jean Jacques Berry |
| requires_python | >=3.6 |
| license | None |
| keywords |
tree
model
grove
forest
|
| VCS |
|
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# xGrove Python Package
Das `xgrove`-Paket bietet eine Klasse zur Berechnung von "Surrogate Groves", um Entscheidungsbäume zu interpretieren. Es ist inspiriert von Methoden aus dem Bereich der Interpretable Machine Learning (IML) und bietet eine Reihe von Funktionen zur Analyse und Visualisierung von Entscheidungsbaumstrukturen.
## Installation
Stelle sicher, dass die erforderlichen Abhängigkeiten installiert sind:
```bash
pip install -r requirements.txt
```
## Klassen und Methoden
### Klasse: `xgrove`
Die Hauptklasse `xgrove` wird verwendet, um "Surrogate Groves" zu erstellen und statistische Analysen durchzuführen.
#### Konstruktor
```python
xgrove(
model,
data: pd.DataFrame,
ntrees: np.array = np.array([4, 8, 16, 32, 64, 128]),
pfun = None,
shrink: int = 1,
b_frac: int = 1,
seed: int = 42,
grove_rate: float = 1
)
```
##### Parameter:
- **model**: Das zu analysierende Modell, typischerweise ein beliebiges ML-Modell.
- **data**: Ein `pandas.DataFrame`, das die Eingabedaten enthält.
- **ntrees**: Ein `np.array`, das die Anzahl der Bäume im Grove angibt.
- **pfun**: Eine Funktion zur Erstellung des Surrogate-Ziels. Falls `None`, wird das Modell zur Vorhersage genutzt.
- **shrink**: Der Shrinkage-Faktor für das Gradient Boosting.
- **b_frac**: Die Fraktion der Stichprobe, die verwendet wird.
- **seed**: Der Seed für die Reproduzierbarkeit.
- **grove_rate**: Die Lernrate für das Grove.
### Methode: `getSurrogateTarget()`
Erzeugt das Surrogate-Ziel basierend auf den Eingabedaten und dem Modell oder der benutzerdefinierten `pfun`.
```python
def getSurrogateTarget(self, pfun):
if self.pfun is None:
target = self.model.predict(self.data)
else:
target = pfun(model=self.model, data=self.data)
return target
```
### Methode: `getGBM()`
Erzeugt ein Gradient Boosting Modell (GBM) mit den angegebenen Parametern.
```python
def getGBM(self):
grove = GradientBoostingRegressor(
n_estimators=self.ntrees,
learning_rate=self.shrink,
subsample=self.b_frac
)
return grove
```
### Methode: `encodeCategorical()`
Codiert kategoriale Variablen mithilfe von One-Hot-Encoding (OHE).
```python
def encodeCategorical(self):
categorical_columns = self.data.select_dtypes(include=['object', 'category']).columns
data_encoded = pd.get_dummies(data, columns=categorical_columns)
return data_encoded
```
### Methode: `upsilon()`
Berechnet die Upsilon-Statistik, die das Verhältnis zwischen erklärtem und unerklärtem Fehler angibt, sowie die Korrelation zwischen den Vorhersagen des Modells und den echten Werten.
```python
def upsilon(self, pexp):
ASE = statistics.mean((self.surrTar - pexp) ** 2)
ASE0 = statistics.mean((self.surrTar - statistics.mean(self.surrTar)) ** 2)
ups = 1 - ASE / ASE0
rho = statistics.correlation(self.surrTar, pexp)
return ups, rho
```
### Methode: `get_result()`
Gibt eine Liste der zentralen Ergebnisse zurück: Erklärung, Regeln, Groves und Modell.
```python
def get_result(self):
res = [self.explanation, self.rules, self.groves, self.model]
return res
```
### Methode: `plot()`
Eine Methode zur Erstellung eines Upsilon-Rules-Plots für den Surrogate Grove. Diese Methode funktioniert ähnlich wie die Plotfunktion in R.
```python
def plot(self, abs="rules", ord="upsilon"):
i = self.explanation.columns.get_loc(abs)
j = self.explanation.columns.get_loc(ord)
plt.plot(self.explanation.iloc[:, i], self.explanation.iloc[:, j], label=f"{abs} vs {ord}", marker="o")
plt.xlabel(abs)
plt.ylabel(ord)
plt.title("Upsilon-Rules Curve")
plt.show()
```
### Methode: `calculateGrove()`
Berechnet die Performance des Modells und extrahiert Groves sowie die dazugehörigen Regeln. Diese Methode füllt die Erklärungs- und Interpretationsdaten und ruft am Ende die `upsilon`-Methode auf, um den Upsilon-Wert zu berechnen.
```python
def calculateGrove(self):
explanation = []
groves = []
interpretation = []
# Für jede Anzahl an Bäumen
for nt in self.ntrees:
predictions = self.surrGrove.staged_predict(self.data)
predictions = [next(predictions) for _ in range(nt)][-1]
rules = []
# Extrahiere Regeln aus den Entscheidungsbäumen
for tid in range(nt):
tree = self.surrGrove.estimators_[tid, 0].tree_
for node_id in range(tree.node_count):
if tree.children_left[node_id] != tree.children_right[node_id]: # Splitsnode
rule = {
'feature': tree.feature[node_id],
'threshold': tree.threshold[node_id],
'pleft': tree.value[tree.children_left[node_id]][0][0],
'pright': tree.value[tree.children_right[node_id]][0][0]
}
rules.append(rule)
rules_df = pd.DataFrame(rules)
groves.append(rules_df)
# Berechne Upsilon und Korrelation
upsilon, rho = self.upsilon(predictions)
# Ergebnisse speichern
explanation.append([nt, len(rules_df), upsilon, rho])
# Ergebnisdaten aufbereiten
groves = pd.DataFrame(groves)
explanation = pd.DataFrame(explanation, columns=["trees", "rules", "upsilon", "cor"])
self.explanation = explanation
self.rules = groves
self.model = self.surrGrove
self.result = self.get_result()
return self.result
```
Raw data
{
"_id": null,
"home_page": null,
"name": "xgrove",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.6",
"maintainer_email": null,
"keywords": "tree, model, grove, forest",
"author": "Jean Jacques Berry",
"author_email": "<J.Jacques.Berry@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/9e/32/77183bf95a371dc94f56d3e5804358e2072acbc45abe3cec94ef9c32d9d2/xgrove-1.0.tar.gz",
"platform": null,
"description": "# xGrove Python Package\r\n\r\nDas `xgrove`-Paket bietet eine Klasse zur Berechnung von \"Surrogate Groves\", um Entscheidungsb\u00e4ume zu interpretieren. Es ist inspiriert von Methoden aus dem Bereich der Interpretable Machine Learning (IML) und bietet eine Reihe von Funktionen zur Analyse und Visualisierung von Entscheidungsbaumstrukturen.\r\n\r\n## Installation\r\n\r\nStelle sicher, dass die erforderlichen Abh\u00e4ngigkeiten installiert sind:\r\n\r\n```bash\r\npip install -r requirements.txt\r\n```\r\n\r\n## Klassen und Methoden\r\n\r\n### Klasse: `xgrove`\r\n\r\nDie Hauptklasse `xgrove` wird verwendet, um \"Surrogate Groves\" zu erstellen und statistische Analysen durchzuf\u00fchren.\r\n\r\n#### Konstruktor\r\n\r\n```python\r\nxgrove(\r\n model, \r\n data: pd.DataFrame, \r\n ntrees: np.array = np.array([4, 8, 16, 32, 64, 128]), \r\n pfun = None, \r\n shrink: int = 1, \r\n b_frac: int = 1, \r\n seed: int = 42, \r\n grove_rate: float = 1\r\n)\r\n```\r\n\r\n##### Parameter:\r\n- **model**: Das zu analysierende Modell, typischerweise ein beliebiges ML-Modell.\r\n- **data**: Ein `pandas.DataFrame`, das die Eingabedaten enth\u00e4lt.\r\n- **ntrees**: Ein `np.array`, das die Anzahl der B\u00e4ume im Grove angibt.\r\n- **pfun**: Eine Funktion zur Erstellung des Surrogate-Ziels. Falls `None`, wird das Modell zur Vorhersage genutzt.\r\n- **shrink**: Der Shrinkage-Faktor f\u00fcr das Gradient Boosting.\r\n- **b_frac**: Die Fraktion der Stichprobe, die verwendet wird.\r\n- **seed**: Der Seed f\u00fcr die Reproduzierbarkeit.\r\n- **grove_rate**: Die Lernrate f\u00fcr das Grove.\r\n\r\n### Methode: `getSurrogateTarget()`\r\n\r\nErzeugt das Surrogate-Ziel basierend auf den Eingabedaten und dem Modell oder der benutzerdefinierten `pfun`.\r\n\r\n```python\r\ndef getSurrogateTarget(self, pfun):\r\n if self.pfun is None:\r\n target = self.model.predict(self.data)\r\n else:\r\n target = pfun(model=self.model, data=self.data)\r\n return target\r\n```\r\n\r\n### Methode: `getGBM()`\r\n\r\nErzeugt ein Gradient Boosting Modell (GBM) mit den angegebenen Parametern.\r\n\r\n```python\r\ndef getGBM(self):\r\n grove = GradientBoostingRegressor(\r\n n_estimators=self.ntrees,\r\n learning_rate=self.shrink,\r\n subsample=self.b_frac\r\n )\r\n return grove\r\n```\r\n\r\n### Methode: `encodeCategorical()`\r\n\r\nCodiert kategoriale Variablen mithilfe von One-Hot-Encoding (OHE).\r\n\r\n```python\r\ndef encodeCategorical(self):\r\n categorical_columns = self.data.select_dtypes(include=['object', 'category']).columns\r\n data_encoded = pd.get_dummies(data, columns=categorical_columns)\r\n return data_encoded\r\n```\r\n\r\n### Methode: `upsilon()`\r\n\r\nBerechnet die Upsilon-Statistik, die das Verh\u00e4ltnis zwischen erkl\u00e4rtem und unerkl\u00e4rtem Fehler angibt, sowie die Korrelation zwischen den Vorhersagen des Modells und den echten Werten.\r\n\r\n```python\r\ndef upsilon(self, pexp):\r\n ASE = statistics.mean((self.surrTar - pexp) ** 2)\r\n ASE0 = statistics.mean((self.surrTar - statistics.mean(self.surrTar)) ** 2)\r\n ups = 1 - ASE / ASE0\r\n rho = statistics.correlation(self.surrTar, pexp)\r\n return ups, rho\r\n```\r\n\r\n### Methode: `get_result()`\r\n\r\nGibt eine Liste der zentralen Ergebnisse zur\u00fcck: Erkl\u00e4rung, Regeln, Groves und Modell.\r\n\r\n```python\r\ndef get_result(self):\r\n res = [self.explanation, self.rules, self.groves, self.model]\r\n return res\r\n```\r\n\r\n### Methode: `plot()`\r\n\r\nEine Methode zur Erstellung eines Upsilon-Rules-Plots f\u00fcr den Surrogate Grove. Diese Methode funktioniert \u00e4hnlich wie die Plotfunktion in R.\r\n\r\n```python\r\ndef plot(self, abs=\"rules\", ord=\"upsilon\"):\r\n i = self.explanation.columns.get_loc(abs)\r\n j = self.explanation.columns.get_loc(ord)\r\n plt.plot(self.explanation.iloc[:, i], self.explanation.iloc[:, j], label=f\"{abs} vs {ord}\", marker=\"o\")\r\n plt.xlabel(abs)\r\n plt.ylabel(ord)\r\n plt.title(\"Upsilon-Rules Curve\")\r\n plt.show()\r\n```\r\n\r\n### Methode: `calculateGrove()`\r\n\r\nBerechnet die Performance des Modells und extrahiert Groves sowie die dazugeh\u00f6rigen Regeln. Diese Methode f\u00fcllt die Erkl\u00e4rungs- und Interpretationsdaten und ruft am Ende die `upsilon`-Methode auf, um den Upsilon-Wert zu berechnen.\r\n\r\n```python\r\ndef calculateGrove(self):\r\n explanation = []\r\n groves = []\r\n interpretation = []\r\n\r\n # F\u00fcr jede Anzahl an B\u00e4umen\r\n for nt in self.ntrees:\r\n predictions = self.surrGrove.staged_predict(self.data)\r\n predictions = [next(predictions) for _ in range(nt)][-1]\r\n rules = []\r\n \r\n # Extrahiere Regeln aus den Entscheidungsb\u00e4umen\r\n for tid in range(nt):\r\n tree = self.surrGrove.estimators_[tid, 0].tree_\r\n for node_id in range(tree.node_count):\r\n if tree.children_left[node_id] != tree.children_right[node_id]: # Splitsnode\r\n rule = {\r\n 'feature': tree.feature[node_id],\r\n 'threshold': tree.threshold[node_id],\r\n 'pleft': tree.value[tree.children_left[node_id]][0][0],\r\n 'pright': tree.value[tree.children_right[node_id]][0][0]\r\n }\r\n rules.append(rule)\r\n rules_df = pd.DataFrame(rules)\r\n groves.append(rules_df)\r\n\r\n # Berechne Upsilon und Korrelation\r\n upsilon, rho = self.upsilon(predictions)\r\n\r\n # Ergebnisse speichern\r\n explanation.append([nt, len(rules_df), upsilon, rho])\r\n\r\n # Ergebnisdaten aufbereiten\r\n groves = pd.DataFrame(groves)\r\n explanation = pd.DataFrame(explanation, columns=[\"trees\", \"rules\", \"upsilon\", \"cor\"])\r\n \r\n self.explanation = explanation\r\n self.rules = groves\r\n self.model = self.surrGrove\r\n\r\n self.result = self.get_result()\r\n return self.result\r\n```\r\n",
"bugtrack_url": null,
"license": null,
"summary": "creating and calculating groves of tree models",
"version": "1.0",
"project_urls": null,
"split_keywords": [
"tree",
" model",
" grove",
" forest"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "483d888af580d1f88b96c5e72a6e587342f1e480189d67f0e346a28c4f47ab16",
"md5": "7881b46aca06f0701c634ed8825c24f8",
"sha256": "fee56bf14170d7cbd76043c955550a84eb903bf581f255c03cea7813170826ad"
},
"downloads": -1,
"filename": "xgrove-1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7881b46aca06f0701c634ed8825c24f8",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.6",
"size": 13961,
"upload_time": "2024-12-08T11:16:34",
"upload_time_iso_8601": "2024-12-08T11:16:34.495373Z",
"url": "https://files.pythonhosted.org/packages/48/3d/888af580d1f88b96c5e72a6e587342f1e480189d67f0e346a28c4f47ab16/xgrove-1.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "9e3277183bf95a371dc94f56d3e5804358e2072acbc45abe3cec94ef9c32d9d2",
"md5": "4cbebb69d80d01c5e90aea5bfb9660a6",
"sha256": "6ae3c0729a0959688c78f977597b215393673269a82cb308f6dde5b5642a44d4"
},
"downloads": -1,
"filename": "xgrove-1.0.tar.gz",
"has_sig": false,
"md5_digest": "4cbebb69d80d01c5e90aea5bfb9660a6",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.6",
"size": 11171,
"upload_time": "2024-12-08T11:16:42",
"upload_time_iso_8601": "2024-12-08T11:16:42.357279Z",
"url": "https://files.pythonhosted.org/packages/9e/32/77183bf95a371dc94f56d3e5804358e2072acbc45abe3cec94ef9c32d9d2/xgrove-1.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-12-08 11:16:42",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "xgrove"
}
