{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Рабочая тетрадь No 5" ] }, { "cell_type": "code", "execution_count": 116, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "from sklearn import tree, metrics\n", "from sklearn.tree import DecisionTreeRegressor\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import classification_report, confusion_matrix" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2.3 Задание\n", "\n", "Создайте класс по работе с тригонометрическими функциями. В классе \n", "должны быть реализованы функции вычисления: \n", "- косинуса; \n", "- синуса; \n", "- тангенса; \n", "- арксинуса; \n", "- арккосинуса; \n", "- арктангенса; \n", "- перевода из градусов в радианы." ] }, { "cell_type": "code", "execution_count": 117, "metadata": {}, "outputs": [], "source": [ "class TrigFunctions:\n", " def __init__(self, precision=10):\n", " # Константа для pi\n", " self.pi = 3.141592653589793\n", " # Переменная точности для вычислений\n", " self.precision = precision\n", "\n", " # Факториал для ряда Тейлора\n", " def factorial(self, n):\n", " result = 1\n", " for i in range(2, n + 1):\n", " result *= i\n", " return result\n", "\n", " # Приближенное вычисление синуса с помощью ряда Тейлора\n", " def sin(self, angle_radians):\n", " sin_approx = 0\n", " \n", " for n in range(self.precision):\n", " sign = (-1) ** n\n", " term = (angle_radians ** (2 * n + 1)) / self.factorial(2 * n + 1)\n", " sin_approx += sign * term\n", " \n", " return sin_approx\n", "\n", " # Приближенное вычисление косинуса с помощью ряда Тейлора\n", " def cos(self, angle_radians):\n", " cos_approx = 0\n", " \n", " for n in range(self.precision):\n", " sign = (-1) ** n\n", " term = (angle_radians ** (2 * n)) / self.factorial(2 * n)\n", " cos_approx += sign * term\n", " \n", " return cos_approx\n", "\n", " # Приближенное вычисление тангенса как sin/cos\n", " def tan(self, angle_radians):\n", " return self.sin(angle_radians) / self.cos(angle_radians)\n", "\n", " # Приближенное вычисление арксинуса с использованием метода Ньютона\n", " def arcsin(self, value):\n", " if value < -1 or value > 1:\n", " return None # Арксинус определен только на отрезке [-1, 1]\n", " \n", " x = value\n", " \n", " for _ in range(self.precision):\n", " x -= (self.sin(x) - value) / self.cos(x)\n", " \n", " return x\n", "\n", " # Арккосинус как pi/2 - арксинус\n", " def arccos(self, value):\n", " return self.pi / 2 - self.arcsin(value)\n", "\n", " # Приближенное вычисление арктангенса с использованием метода Ньютона\n", " def arctan(self, value):\n", " x = value\n", " \n", " for _ in range(self.precision):\n", " x -= (self.tan(x) - value) / (1 + value ** 2)\n", " \n", " return x" ] }, { "cell_type": "code", "execution_count": 118, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Угол (рад): 0.7853981633974483\n", "sin: 0.7071067811865475\n", "cos: 0.7071067811865475\n", "tan: 1.0\n", "arcsin (рад): 0.7853981633974483\n", "arccos (рад): 0.7853981633974483\n", "arctan (рад): 0.7853981633974483\n" ] } ], "source": [ "trig_functions = TrigFunctions(precision=10)\n", "\n", "angle = 3.141592653589793 / 4 # pi/4 радиан (45 градусов)\n", "\n", "sin_value = trig_functions.sin(angle)\n", "cos_value = trig_functions.cos(angle)\n", "tan_value = trig_functions.tan(angle)\n", "arcsin_value = trig_functions.arcsin(sin_value)\n", "arccos_value = trig_functions.arccos(cos_value)\n", "arctan_value = trig_functions.arctan(tan_value)\n", "\n", "print(\"Угол (рад):\", angle)\n", "print(\"sin:\", sin_value)\n", "print(\"cos:\", cos_value)\n", "print(\"tan:\", tan_value)\n", "print(\"arcsin (рад):\", arcsin_value)\n", "print(\"arccos (рад):\", arccos_value)\n", "print(\"arctan (рад):\", arctan_value)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2.2 Задание 1\n", "\n", "Представьте дерево показанное на рисунке с использованием списка из \n", "списков. Выведите на печать корень дерева, а также его левое и правое \n", "поддеревья." ] }, { "cell_type": "code", "execution_count": 119, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Корень: a\n", "Левое поддерево: ['b', ['d', []], ['e', []]]\n", "Правое поддерево: ['c', ['f', []]]\n" ] } ], "source": [ "tr = ['a', ['b', ['d', []], ['e', []]], ['c', ['f', []]]]\n", "\n", "print(f\"Корень: {tr[0]}\")\n", "print(f\"Левое поддерево: {tr[1]}\")\n", "print(f\"Правое поддерево: {tr[2]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2.2 Задание 2\n", "\n", "Дан класс, описывающий бинарное дерево. \n", "\n", "\n", "```python\n", "class Tree: \n", " def __init__(self, data): \n", " self.left = None \n", " self.right = None \n", " self.data = data \n", " def PrintTree(self): \n", " print(self.data) \n", "```\n", "Реализуйте в классе функцию для вставки нового элемента в дерево по \n", "следующим правилам: \n", " \n", "- Левое поддерево узла содержит только узлы со значениями меньше, \n", "чем значение в узле. \n", "- Правое поддерево узла содержит только узлы со значениями меньше, \n", "чем значение в узле. \n", "- Каждое из левого и правого поддеревьев также должно быть \n", "бинарным деревом поиска. \n", "- Не должно быть повторяющихся узлов. \n", "\n", "Метод вставки сравнивает значение узла с родительским узлом и решает \n", "куда доваить элемент (в левое или правое поддерево). Перепишите, метод \n", "PrintTree для печати полной версии дерева." ] }, { "cell_type": "code", "execution_count": 120, "metadata": {}, "outputs": [], "source": [ "class BinaryTree: \n", " def __init__(self, data): \n", " self.left = None \n", " self.right = None \n", " self.data = data\n", "\n", " def insert(self, data):\n", " if data < self.data:\n", " if self.left is None:\n", " self.left = BinaryTree(data)\n", " else:\n", " self.left.insert(data)\n", " elif data > self.data:\n", " if self.right is None:\n", " self.right = BinaryTree(data)\n", " else:\n", " self.right.insert(data)\n", "\n", " def Print(self, level=0):\n", " if self.right:\n", " self.right.Print(level + 1)\n", " \n", " print(' ' * 4 * level + '->', self.data)\n", " if self.left:\n", " self.left.Print(level + 1) " ] }, { "cell_type": "code", "execution_count": 121, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " -> 17\n", " -> 15\n", " -> 12\n", "-> 10\n", " -> 7\n", " -> 5\n", " -> 3\n" ] } ], "source": [ "root = BinaryTree(10)\n", "root.insert(5)\n", "root.insert(15)\n", "root.insert(3)\n", "root.insert(7)\n", "root.insert(12)\n", "root.insert(17)\n", "\n", "root.Print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3.1 Задание\n", "\n", "Постройте классификатор на основе дерева принятия решений следующего датасета:\n", "\n", "```python\n", "X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])\n", "target = [0, 0, 0, 1, 1, 1]\n", "```" ] }, { "cell_type": "code", "execution_count": 122, "metadata": {}, "outputs": [], "source": [ "ds = pd.DataFrame(np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]))\n", "target = [0, 0, 0, 1, 1, 1]" ] }, { "cell_type": "code", "execution_count": 123, "metadata": {}, "outputs": [], "source": [ "x_train, x_test, y_train, y_test = train_test_split(ds, target, test_size=0.2)" ] }, { "cell_type": "code", "execution_count": 124, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Text(0.5, 0.75, 'x[1] <= -0.5\\ngini = 0.375\\nsamples = 4\\nvalue = [1, 3]'),\n", " Text(0.25, 0.25, 'gini = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n", " Text(0.375, 0.5, 'True '),\n", " Text(0.75, 0.25, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 3]'),\n", " Text(0.625, 0.5, ' False')]" ] }, "execution_count": 124, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "classifier = DecisionTreeClassifier()\n", "classifier.fit(x_train, y_train)\n", "\n", "tree.plot_tree(classifier)" ] }, { "cell_type": "code", "execution_count": 125, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 0]\n", "[[2]]\n", " precision recall f1-score support\n", "\n", " 0 1.00 1.00 1.00 2\n", "\n", " accuracy 1.00 2\n", " macro avg 1.00 1.00 1.00 2\n", "weighted avg 1.00 1.00 1.00 2\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/nktkln/.pyenv/versions/3.11.0/lib/python3.11/site-packages/sklearn/metrics/_classification.py:409: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n", " warnings.warn(\n" ] } ], "source": [ "y_pred = classifier.predict(x_test)\n", "\n", "print(y_pred)\n", "print(confusion_matrix(y_test, y_pred))\n", "print(classification_report(y_test, y_pred))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.4.1 Задание\n", "\n", "Задание. Постройте модель регрессии для данных из предыдущей рабочей \n", "тетради.Для примера можно взять потребления газа (в миллионах \n", "галлонов) в 48 штатах США или набор данных о качестве красного вина: \n", "https://raw.githubusercontent.com/likarajo/petrol_consumption/master/data/petrol_consumption.csv \n", "https://raw.githubusercontent.com/aniruddhachoudhury/Red-Wine-Quality/master/winequality-red.csv \n", "\n", "Постройте прогноз. Оцените точность модели." ] }, { "cell_type": "code", "execution_count": 126, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
fixed acidityvolatile aciditycitric acidresidual sugarchloridesfree sulfur dioxidetotal sulfur dioxidedensitypHsulphatesalcoholquality
count1599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.0000001599.000000
mean8.3196370.5278210.2709762.5388060.08746715.87492246.4677920.9967473.3111130.65814910.4229835.636023
std1.7410960.1790600.1948011.4099280.04706510.46015732.8953240.0018870.1543860.1695071.0656680.807569
min4.6000000.1200000.0000000.9000000.0120001.0000006.0000000.9900702.7400000.3300008.4000003.000000
25%7.1000000.3900000.0900001.9000000.0700007.00000022.0000000.9956003.2100000.5500009.5000005.000000
50%7.9000000.5200000.2600002.2000000.07900014.00000038.0000000.9967503.3100000.62000010.2000006.000000
75%9.2000000.6400000.4200002.6000000.09000021.00000062.0000000.9978353.4000000.73000011.1000006.000000
max15.9000001.5800001.00000015.5000000.61100072.000000289.0000001.0036904.0100002.00000014.9000008.000000
\n", "
" ], "text/plain": [ " fixed acidity volatile acidity citric acid residual sugar \n", "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", "mean 8.319637 0.527821 0.270976 2.538806 \n", "std 1.741096 0.179060 0.194801 1.409928 \n", "min 4.600000 0.120000 0.000000 0.900000 \n", "25% 7.100000 0.390000 0.090000 1.900000 \n", "50% 7.900000 0.520000 0.260000 2.200000 \n", "75% 9.200000 0.640000 0.420000 2.600000 \n", "max 15.900000 1.580000 1.000000 15.500000 \n", "\n", " chlorides free sulfur dioxide total sulfur dioxide density \n", "count 1599.000000 1599.000000 1599.000000 1599.000000 \\\n", "mean 0.087467 15.874922 46.467792 0.996747 \n", "std 0.047065 10.460157 32.895324 0.001887 \n", "min 0.012000 1.000000 6.000000 0.990070 \n", "25% 0.070000 7.000000 22.000000 0.995600 \n", "50% 0.079000 14.000000 38.000000 0.996750 \n", "75% 0.090000 21.000000 62.000000 0.997835 \n", "max 0.611000 72.000000 289.000000 1.003690 \n", "\n", " pH sulphates alcohol quality \n", "count 1599.000000 1599.000000 1599.000000 1599.000000 \n", "mean 3.311113 0.658149 10.422983 5.636023 \n", "std 0.154386 0.169507 1.065668 0.807569 \n", "min 2.740000 0.330000 8.400000 3.000000 \n", "25% 3.210000 0.550000 9.500000 5.000000 \n", "50% 3.310000 0.620000 10.200000 6.000000 \n", "75% 3.400000 0.730000 11.100000 6.000000 \n", "max 4.010000 2.000000 14.900000 8.000000 " ] }, "execution_count": 126, "metadata": {}, "output_type": "execute_result" } ], "source": [ "url = 'https://raw.githubusercontent.com/aniruddhachoudhury/Red-Wine-Quality/master/winequality-red.csv'\n", "\n", "ds = pd.read_csv(url)\n", "\n", "ds.describe()" ] }, { "cell_type": "code", "execution_count": 127, "metadata": {}, "outputs": [], "source": [ "X = ds.iloc[:, :-1].values\n", "y = ds.iloc[:, -1].values\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" ] }, { "cell_type": "code", "execution_count": 128, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[Text(0.49800740259424797, 0.9722222222222222, 'x[10] <= 10.525\\nsquared_error = 0.671\\nsamples = 1279\\nvalue = 5.647'),\n", " Text(0.214837677322192, 0.9166666666666666, 'x[9] <= 0.575\\nsquared_error = 0.431\\nsamples = 789\\nvalue = 5.373'),\n", " Text(0.35642253995822, 0.9444444444444444, 'True '),\n", " Text(0.10466867469879518, 0.8611111111111112, 'x[4] <= 0.251\\nsquared_error = 0.329\\nsamples = 323\\nvalue = 5.164'),\n", " Text(0.101559463661096, 0.8055555555555556, 'x[1] <= 0.587\\nsquared_error = 0.316\\nsamples = 322\\nvalue = 5.171'),\n", " Text(0.07267780800621843, 0.75, 'x[10] <= 10.05\\nsquared_error = 0.338\\nsamples = 148\\nvalue = 5.284'),\n", " Text(0.04508356004663817, 0.6944444444444444, 'x[4] <= 0.08\\nsquared_error = 0.267\\nsamples = 114\\nvalue = 5.175'),\n", " Text(0.027982899339292655, 0.6388888888888888, 'x[7] <= 0.996\\nsquared_error = 0.38\\nsamples = 58\\nvalue = 5.293'),\n", " Text(0.01554605518849592, 0.5833333333333334, 'x[8] <= 3.365\\nsquared_error = 0.196\\nsamples = 15\\nvalue = 4.933'),\n", " Text(0.009327633113097552, 0.5277777777777778, 'x[1] <= 0.44\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 5.091'),\n", " Text(0.006218422075398368, 0.4722222222222222, 'x[6] <= 91.0\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.003109211037699184, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.009327633113097552, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.012436844150796735, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", " Text(0.021764477263894286, 0.5277777777777778, 'x[5] <= 13.5\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 4.5'),\n", " Text(0.018655266226195105, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.02487368830159347, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.04041974349008939, 0.5833333333333334, 'x[2] <= 0.075\\nsquared_error = 0.383\\nsamples = 43\\nvalue = 5.419'),\n", " Text(0.034201321414691024, 0.5277777777777778, 'x[4] <= 0.073\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 6.2'),\n", " Text(0.03109211037699184, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.03731053245239021, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.046638165565487756, 0.5277777777777778, 'x[8] <= 3.375\\nsquared_error = 0.321\\nsamples = 38\\nvalue = 5.316'),\n", " Text(0.04352895452778857, 0.4722222222222222, 'x[4] <= 0.058\\nsquared_error = 0.298\\nsamples = 34\\nvalue = 5.235'),\n", " Text(0.04041974349008939, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.046638165565487756, 0.4166666666666667, 'x[3] <= 3.9\\nsquared_error = 0.259\\nsamples = 33\\nvalue = 5.273'),\n", " Text(0.04352895452778857, 0.3611111111111111, 'x[7] <= 1.0\\nsquared_error = 0.215\\nsamples = 32\\nvalue = 5.312'),\n", " Text(0.04041974349008939, 0.3055555555555556, 'x[7] <= 0.996\\nsquared_error = 0.196\\nsamples = 30\\nvalue = 5.267'),\n", " Text(0.034201321414691024, 0.25, 'x[8] <= 3.31\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", " Text(0.03109211037699184, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.03731053245239021, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.046638165565487756, 0.25, 'x[5] <= 5.5\\nsquared_error = 0.139\\nsamples = 24\\nvalue = 5.167'),\n", " Text(0.04352895452778857, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.04974737660318694, 0.19444444444444445, 'x[0] <= 7.25\\nsquared_error = 0.113\\nsamples = 23\\nvalue = 5.13'),\n", " Text(0.046638165565487756, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.052856587640886125, 0.1388888888888889, 'x[6] <= 77.5\\nsquared_error = 0.083\\nsamples = 22\\nvalue = 5.091'),\n", " Text(0.04974737660318694, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 15\\nvalue = 5.0'),\n", " Text(0.05596579867858531, 0.08333333333333333, 'x[6] <= 116.5\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 5.286'),\n", " Text(0.052856587640886125, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.059075009716284495, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.046638165565487756, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.04974737660318694, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.04974737660318694, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.06218422075398368, 0.6388888888888888, 'x[6] <= 14.5\\nsquared_error = 0.122\\nsamples = 56\\nvalue = 5.054'),\n", " Text(0.059075009716284495, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.06529343179168286, 0.5833333333333334, 'x[10] <= 9.75\\nsquared_error = 0.104\\nsamples = 55\\nvalue = 5.073'),\n", " Text(0.059075009716284495, 0.5277777777777778, 'x[10] <= 9.025\\nsquared_error = 0.06\\nsamples = 50\\nvalue = 5.02'),\n", " Text(0.05596579867858531, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.06218422075398368, 0.4722222222222222, 'x[10] <= 9.075\\nsquared_error = 0.041\\nsamples = 49\\nvalue = 5.0'),\n", " Text(0.059075009716284495, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.06529343179168286, 0.4166666666666667, 'x[8] <= 3.36\\nsquared_error = 0.02\\nsamples = 48\\nvalue = 5.021'),\n", " Text(0.06218422075398368, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 41\\nvalue = 5.0'),\n", " Text(0.06840264282938205, 0.3611111111111111, 'x[5] <= 14.0\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 5.143'),\n", " Text(0.06529343179168286, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.07151185386708123, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", " Text(0.07151185386708123, 0.5277777777777778, 'x[0] <= 7.45\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.6'),\n", " Text(0.06840264282938205, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.07462106490478042, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.10027205596579868, 0.6944444444444444, 'x[2] <= 0.015\\nsquared_error = 0.405\\nsamples = 34\\nvalue = 5.647'),\n", " Text(0.0971628449280995, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.10338126700349787, 0.6388888888888888, 'x[1] <= 0.565\\nsquared_error = 0.309\\nsamples = 32\\nvalue = 5.562'),\n", " Text(0.0948309366498251, 0.5833333333333334, 'x[10] <= 10.45\\nsquared_error = 0.226\\nsamples = 29\\nvalue = 5.655'),\n", " Text(0.08705790905557714, 0.5277777777777778, 'x[3] <= 1.85\\nsquared_error = 0.166\\nsamples = 19\\nvalue = 5.789'),\n", " Text(0.08083948698017877, 0.4722222222222222, 'x[10] <= 10.35\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.0777302759424796, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.08394869801787797, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.09327633113097551, 0.4722222222222222, 'x[9] <= 0.535\\nsquared_error = 0.109\\nsamples = 16\\nvalue = 5.875'),\n", " Text(0.09016712009327633, 0.4166666666666667, 'x[1] <= 0.465\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", " Text(0.08705790905557714, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.09327633113097551, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.0963855421686747, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", " Text(0.10260396424407307, 0.5277777777777778, 'x[8] <= 3.305\\nsquared_error = 0.24\\nsamples = 10\\nvalue = 5.4'),\n", " Text(0.09949475320637388, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", " Text(0.10571317528177225, 0.4722222222222222, 'x[4] <= 0.08\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.667'),\n", " Text(0.10260396424407307, 0.4166666666666667, 'x[2] <= 0.485\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.09949475320637388, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.10571317528177225, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.10882238631947143, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.11193159735717062, 0.5833333333333334, 'x[5] <= 15.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.667'),\n", " Text(0.10882238631947143, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.1150408083948698, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.13044111931597357, 0.75, 'x[3] <= 1.25\\nsquared_error = 0.276\\nsamples = 174\\nvalue = 5.075'),\n", " Text(0.1273319082782744, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.13355033035367275, 0.6944444444444444, 'x[7] <= 0.994\\nsquared_error = 0.256\\nsamples = 173\\nvalue = 5.064'),\n", " Text(0.13044111931597357, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", " Text(0.13665954139137193, 0.6388888888888888, 'x[5] <= 3.5\\nsquared_error = 0.24\\nsamples = 170\\nvalue = 5.082'),\n", " Text(0.12436844150796736, 0.5833333333333334, 'x[10] <= 10.25\\nsquared_error = 1.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.12125923047026817, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", " Text(0.12747765254566654, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.14895064127477653, 0.5833333333333334, 'x[9] <= 0.495\\nsquared_error = 0.217\\nsamples = 168\\nvalue = 5.095'),\n", " Text(0.1336960746210649, 0.5277777777777778, 'x[0] <= 8.85\\nsquared_error = 0.126\\nsamples = 47\\nvalue = 4.957'),\n", " Text(0.12747765254566654, 0.4722222222222222, 'x[1] <= 0.752\\nsquared_error = 0.09\\nsamples = 40\\nvalue = 4.9'),\n", " Text(0.12436844150796736, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 25\\nvalue = 5.0'),\n", " Text(0.13058686358336571, 0.4166666666666667, 'x[2] <= 0.265\\nsquared_error = 0.196\\nsamples = 15\\nvalue = 4.733'),\n", " Text(0.12747765254566654, 0.3611111111111111, 'x[2] <= 0.015\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 4.846'),\n", " Text(0.12436844150796736, 0.3055555555555556, 'x[4] <= 0.095\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.333'),\n", " Text(0.12125923047026817, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.12747765254566654, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.13058686358336571, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 10\\nvalue = 5.0'),\n", " Text(0.1336960746210649, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.13991449669646328, 0.4722222222222222, 'x[0] <= 9.1\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 5.286'),\n", " Text(0.1368052856587641, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.14302370773416245, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.16420520792848814, 0.5277777777777778, 'x[4] <= 0.062\\nsquared_error = 0.242\\nsamples = 121\\nvalue = 5.149'),\n", " Text(0.15235134084726001, 0.4722222222222222, 'x[6] <= 30.0\\nsquared_error = 1.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.14924212980956084, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.1554605518849592, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", " Text(0.1760590750097163, 0.4722222222222222, 'x[2] <= 0.23\\nsquared_error = 0.207\\nsamples = 119\\nvalue = 5.168'),\n", " Text(0.16167897396035755, 0.4166666666666667, 'x[8] <= 3.345\\nsquared_error = 0.186\\nsamples = 81\\nvalue = 5.247'),\n", " Text(0.1531286436066848, 0.3611111111111111, 'x[8] <= 3.305\\nsquared_error = 0.232\\nsamples = 41\\nvalue = 5.366'),\n", " Text(0.14535561601243685, 0.3055555555555556, 'x[8] <= 3.245\\nsquared_error = 0.175\\nsamples = 31\\nvalue = 5.226'),\n", " Text(0.14224640497473767, 0.25, 'x[0] <= 8.1\\nsquared_error = 0.249\\nsamples = 15\\nvalue = 5.467'),\n", " Text(0.1360279828993393, 0.19444444444444445, 'x[5] <= 10.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.833'),\n", " Text(0.1329187718616401, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.13913719393703847, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.14846482705013603, 0.19444444444444445, 'x[10] <= 9.8\\nsquared_error = 0.173\\nsamples = 9\\nvalue = 5.222'),\n", " Text(0.14535561601243685, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 7\\nvalue = 5.0'),\n", " Text(0.1515740380878352, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.14846482705013603, 0.25, 'squared_error = 0.0\\nsamples = 16\\nvalue = 5.0'),\n", " Text(0.16090167120093277, 0.3055555555555556, 'x[9] <= 0.535\\nsquared_error = 0.16\\nsamples = 10\\nvalue = 5.8'),\n", " Text(0.1577924601632336, 0.25, 'x[2] <= 0.02\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.15468324912553438, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.16090167120093277, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.16401088223863194, 0.25, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", " Text(0.17022930431403033, 0.3611111111111111, 'x[1] <= 0.595\\nsquared_error = 0.109\\nsamples = 40\\nvalue = 5.125'),\n", " Text(0.16712009327633112, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.1733385153517295, 0.3055555555555556, 'x[10] <= 10.25\\nsquared_error = 0.073\\nsamples = 38\\nvalue = 5.079'),\n", " Text(0.17022930431403033, 0.25, 'x[3] <= 9.3\\nsquared_error = 0.051\\nsamples = 37\\nvalue = 5.054'),\n", " Text(0.16712009327633112, 0.19444444444444445, 'x[7] <= 0.998\\nsquared_error = 0.027\\nsamples = 36\\nvalue = 5.028'),\n", " Text(0.16401088223863194, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 33\\nvalue = 5.0'),\n", " Text(0.17022930431403033, 0.1388888888888889, 'x[7] <= 0.999\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.16712009327633112, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.1733385153517295, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.1733385153517295, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.17644772638942868, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.190439176059075, 0.4166666666666667, 'x[6] <= 59.5\\nsquared_error = 0.211\\nsamples = 38\\nvalue = 5.0'),\n", " Text(0.18266614846482704, 0.3611111111111111, 'x[5] <= 10.0\\nsquared_error = 0.247\\nsamples = 9\\nvalue = 4.556'),\n", " Text(0.17955693742712786, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.18577535950252624, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 4\\nvalue = 4.0'),\n", " Text(0.19821220365332298, 0.3611111111111111, 'x[5] <= 17.5\\nsquared_error = 0.119\\nsamples = 29\\nvalue = 5.138'),\n", " Text(0.1919937815779246, 0.3055555555555556, 'x[6] <= 92.0\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", " Text(0.18888457054022542, 0.25, 'x[0] <= 8.2\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.75'),\n", " Text(0.18577535950252624, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.1919937815779246, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.19510299261562378, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.20443062572872134, 0.3055555555555556, 'x[10] <= 10.05\\nsquared_error = 0.042\\nsamples = 23\\nvalue = 5.043'),\n", " Text(0.20132141469102216, 0.25, 'squared_error = 0.0\\nsamples = 21\\nvalue = 5.0'),\n", " Text(0.20753983676642052, 0.25, 'x[5] <= 23.5\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.20443062572872134, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.2106490478041197, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.10777788573649437, 0.8055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", " Text(0.3250066799455888, 0.8611111111111112, 'x[1] <= 0.365\\nsquared_error = 0.451\\nsamples = 466\\nvalue = 5.517'),\n", " Text(0.19976680917217257, 0.8055555555555556, 'x[9] <= 0.65\\nsquared_error = 0.457\\nsamples = 72\\nvalue = 5.958'),\n", " Text(0.18266614846482704, 0.75, 'x[1] <= 0.355\\nsquared_error = 0.249\\nsamples = 17\\nvalue = 5.471'),\n", " Text(0.17955693742712786, 0.6944444444444444, 'x[8] <= 3.17\\nsquared_error = 0.213\\nsamples = 13\\nvalue = 5.308'),\n", " Text(0.17644772638942868, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.18266614846482704, 0.6388888888888888, 'x[1] <= 0.23\\nsquared_error = 0.149\\nsamples = 11\\nvalue = 5.182'),\n", " Text(0.17955693742712786, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.18577535950252624, 0.5833333333333334, 'x[5] <= 19.5\\nsquared_error = 0.09\\nsamples = 10\\nvalue = 5.1'),\n", " Text(0.18266614846482704, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", " Text(0.18888457054022542, 0.5277777777777778, 'x[10] <= 9.45\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", " Text(0.18577535950252624, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.1919937815779246, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.18577535950252624, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.21686746987951808, 0.75, 'x[10] <= 9.75\\nsquared_error = 0.424\\nsamples = 55\\nvalue = 6.109'),\n", " Text(0.20753983676642052, 0.6944444444444444, 'x[0] <= 14.65\\nsquared_error = 0.332\\nsamples = 24\\nvalue = 5.792'),\n", " Text(0.20443062572872134, 0.6388888888888888, 'x[10] <= 9.45\\nsquared_error = 0.217\\nsamples = 22\\nvalue = 5.682'),\n", " Text(0.19821220365332298, 0.5833333333333334, 'x[2] <= 0.395\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 5.917'),\n", " Text(0.19510299261562378, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.20132141469102216, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", " Text(0.2106490478041197, 0.5833333333333334, 'x[1] <= 0.33\\nsquared_error = 0.24\\nsamples = 10\\nvalue = 5.4'),\n", " Text(0.20753983676642052, 0.5277777777777778, 'x[9] <= 0.74\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 5.25'),\n", " Text(0.20443062572872134, 0.4722222222222222, 'x[4] <= 0.087\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", " Text(0.20132141469102216, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.20753983676642052, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.2106490478041197, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.2137582588418189, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.2106490478041197, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.22619510299261564, 0.6944444444444444, 'x[1] <= 0.245\\nsquared_error = 0.358\\nsamples = 31\\nvalue = 6.355'),\n", " Text(0.21997668091721725, 0.6388888888888888, 'x[10] <= 10.45\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 5.875'),\n", " Text(0.21686746987951808, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", " Text(0.22308589195491643, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.232413525068014, 0.6388888888888888, 'x[5] <= 4.0\\nsquared_error = 0.336\\nsamples = 23\\nvalue = 6.522'),\n", " Text(0.22930431403031482, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.23552273610571317, 0.5833333333333334, 'x[2] <= 0.515\\nsquared_error = 0.248\\nsamples = 22\\nvalue = 6.455'),\n", " Text(0.22930431403031482, 0.5277777777777778, 'x[7] <= 0.998\\nsquared_error = 0.215\\nsamples = 16\\nvalue = 6.312'),\n", " Text(0.22619510299261564, 0.4722222222222222, 'x[7] <= 0.998\\nsquared_error = 0.248\\nsamples = 11\\nvalue = 6.455'),\n", " Text(0.22308589195491643, 0.4166666666666667, 'x[3] <= 1.5\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 6.25'),\n", " Text(0.21997668091721725, 0.3611111111111111, 'x[1] <= 0.315\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.667'),\n", " Text(0.21686746987951808, 0.3055555555555556, 'x[8] <= 3.39\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", " Text(0.2137582588418189, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.21997668091721725, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.22308589195491643, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.22619510299261564, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.22930431403031482, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", " Text(0.232413525068014, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.24174115818111155, 0.5277777777777778, 'x[7] <= 0.998\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", " Text(0.23863194714341235, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", " Text(0.24485036921881073, 0.4722222222222222, 'x[4] <= 0.075\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", " Text(0.24174115818111155, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.2479595802565099, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.45024655071900505, 0.8055555555555556, 'x[6] <= 55.5\\nsquared_error = 0.408\\nsamples = 394\\nvalue = 5.437'),\n", " Text(0.4111810143801011, 0.75, 'x[8] <= 3.535\\nsquared_error = 0.463\\nsamples = 249\\nvalue = 5.558'),\n", " Text(0.3800767586474932, 0.6944444444444444, 'x[5] <= 33.0\\nsquared_error = 0.43\\nsamples = 227\\nvalue = 5.617'),\n", " Text(0.33963272444617176, 0.6388888888888888, 'x[9] <= 0.685\\nsquared_error = 0.393\\nsamples = 222\\nvalue = 5.64'),\n", " Text(0.2921686746987952, 0.5833333333333334, 'x[3] <= 1.85\\nsquared_error = 0.348\\nsamples = 142\\nvalue = 5.528'),\n", " Text(0.2635056354450058, 0.5277777777777778, 'x[4] <= 0.083\\nsquared_error = 0.227\\nsamples = 30\\nvalue = 5.2'),\n", " Text(0.25728721336960747, 0.4722222222222222, 'x[7] <= 0.998\\nsquared_error = 0.141\\nsamples = 21\\nvalue = 5.048'),\n", " Text(0.2541780023319083, 0.4166666666666667, 'x[7] <= 0.996\\nsquared_error = 0.09\\nsamples = 20\\nvalue = 5.1'),\n", " Text(0.2510687912942091, 0.3611111111111111, 'x[10] <= 9.65\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", " Text(0.2479595802565099, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.2541780023319083, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.25728721336960747, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 15\\nvalue = 5.0'),\n", " Text(0.26039642440730665, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.2697240575204042, 0.4722222222222222, 'x[4] <= 0.094\\nsquared_error = 0.247\\nsamples = 9\\nvalue = 5.556'),\n", " Text(0.266614846482705, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.27283326855810336, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", " Text(0.32083171395258453, 0.5277777777777778, 'x[3] <= 2.65\\nsquared_error = 0.344\\nsamples = 112\\nvalue = 5.616'),\n", " Text(0.29731830547998445, 0.4722222222222222, 'x[4] <= 0.076\\nsquared_error = 0.349\\nsamples = 94\\nvalue = 5.67'),\n", " Text(0.27905169063350177, 0.4166666666666667, 'x[5] <= 26.5\\nsquared_error = 0.358\\nsamples = 37\\nvalue = 5.514'),\n", " Text(0.2759424795958026, 0.3611111111111111, 'x[6] <= 25.5\\nsquared_error = 0.245\\nsamples = 35\\nvalue = 5.429'),\n", " Text(0.26506024096385544, 0.3055555555555556, 'x[10] <= 9.25\\nsquared_error = 0.18\\nsamples = 17\\nvalue = 5.765'),\n", " Text(0.25884181888845703, 0.25, 'x[1] <= 0.46\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.25573260785075785, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.26195102992615626, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.2712786630392538, 0.25, 'x[7] <= 0.996\\nsquared_error = 0.122\\nsamples = 14\\nvalue = 5.857'),\n", " Text(0.2681694520015546, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.274387874076953, 0.19444444444444445, 'x[9] <= 0.625\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 5.923'),\n", " Text(0.2712786630392538, 0.1388888888888889, 'x[8] <= 3.15\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", " Text(0.2681694520015546, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.274387874076953, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.27749708511465215, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", " Text(0.2868247182277497, 0.3055555555555556, 'x[2] <= 0.135\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 5.111'),\n", " Text(0.2837155071900505, 0.25, 'x[3] <= 2.15\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", " Text(0.28060629615235133, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.2868247182277497, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.2899339292654489, 0.25, 'squared_error = 0.0\\nsamples = 13\\nvalue = 5.0'),\n", " Text(0.28216090167120095, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.3155849203264672, 0.4166666666666667, 'x[10] <= 10.45\\nsquared_error = 0.316\\nsamples = 57\\nvalue = 5.772'),\n", " Text(0.312475709288768, 0.3611111111111111, 'x[7] <= 0.997\\nsquared_error = 0.299\\nsamples = 54\\nvalue = 5.815'),\n", " Text(0.29926156237854645, 0.3055555555555556, 'x[8] <= 3.475\\nsquared_error = 0.094\\nsamples = 19\\nvalue = 6.105'),\n", " Text(0.2961523513408473, 0.25, 'x[7] <= 0.997\\nsquared_error = 0.052\\nsamples = 18\\nvalue = 6.056'),\n", " Text(0.2930431403031481, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", " Text(0.29926156237854645, 0.19444444444444445, 'x[6] <= 37.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.333'),\n", " Text(0.2961523513408473, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.30237077341624563, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.30237077341624563, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.3256898561989895, 0.3055555555555556, 'x[5] <= 14.5\\nsquared_error = 0.34\\nsamples = 35\\nvalue = 5.657'),\n", " Text(0.3225806451612903, 0.25, 'x[0] <= 9.7\\nsquared_error = 0.302\\nsamples = 29\\nvalue = 5.793'),\n", " Text(0.31480761756704234, 0.19444444444444445, 'x[8] <= 3.265\\nsquared_error = 0.231\\nsamples = 22\\nvalue = 5.636'),\n", " Text(0.308589195491644, 0.1388888888888889, 'x[0] <= 7.75\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", " Text(0.3054799844539448, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.31169840652934316, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.32102603964244075, 0.1388888888888889, 'x[2] <= 0.33\\nsquared_error = 0.152\\nsamples = 16\\nvalue = 5.812'),\n", " Text(0.3179168286047415, 0.08333333333333333, 'x[2] <= 0.085\\nsquared_error = 0.066\\nsamples = 14\\nvalue = 5.929'),\n", " Text(0.31480761756704234, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.32102603964244075, 0.027777777777777776, 'squared_error = 0.0\\nsamples = 13\\nvalue = 6.0'),\n", " Text(0.32413525068013993, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.3303536727555383, 0.19444444444444445, 'x[6] <= 43.0\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 6.286'),\n", " Text(0.3272444617178391, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.33346288379323746, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.32879906723668867, 0.25, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", " Text(0.31869413136416636, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.3443451224251846, 0.4722222222222222, 'x[10] <= 10.35\\nsquared_error = 0.222\\nsamples = 18\\nvalue = 5.333'),\n", " Text(0.33812670034978626, 0.4166666666666667, 'x[3] <= 7.45\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 5.154'),\n", " Text(0.3350174893120871, 0.3611111111111111, 'x[7] <= 0.999\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 5.083'),\n", " Text(0.33190827827438785, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 8\\nvalue = 5.0'),\n", " Text(0.33812670034978626, 0.3055555555555556, 'x[4] <= 0.094\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", " Text(0.3350174893120871, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.34123591138748544, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.34123591138748544, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.35056354450058297, 0.4166666666666667, 'x[3] <= 3.3\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 5.8'),\n", " Text(0.3474543334628838, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.35367275553828215, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.3870967741935484, 0.5833333333333334, 'x[10] <= 9.85\\nsquared_error = 0.411\\nsamples = 80\\nvalue = 5.838'),\n", " Text(0.3692188107267781, 0.5277777777777778, 'x[7] <= 0.997\\nsquared_error = 0.287\\nsamples = 44\\nvalue = 5.591'),\n", " Text(0.3598911776136805, 0.4722222222222222, 'x[1] <= 0.385\\nsquared_error = 0.312\\nsamples = 16\\nvalue = 5.25'),\n", " Text(0.3567819665759813, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.36300038865137974, 0.4166666666666667, 'x[10] <= 9.15\\nsquared_error = 0.116\\nsamples = 15\\nvalue = 5.133'),\n", " Text(0.3598911776136805, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.3661095996890789, 0.3611111111111111, 'x[8] <= 3.41\\nsquared_error = 0.066\\nsamples = 14\\nvalue = 5.071'),\n", " Text(0.36300038865137974, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 13\\nvalue = 5.0'),\n", " Text(0.3692188107267781, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.3785464438398756, 0.4722222222222222, 'x[10] <= 9.45\\nsquared_error = 0.168\\nsamples = 28\\nvalue = 5.786'),\n", " Text(0.37543723280217645, 0.4166666666666667, 'x[7] <= 0.998\\nsquared_error = 0.24\\nsamples = 15\\nvalue = 5.6'),\n", " Text(0.37232802176447727, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.3785464438398756, 0.3611111111111111, 'x[2] <= 0.27\\nsquared_error = 0.188\\nsamples = 12\\nvalue = 5.75'),\n", " Text(0.37543723280217645, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", " Text(0.3816556548775748, 0.3055555555555556, 'x[8] <= 3.075\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", " Text(0.3785464438398756, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.384764865915274, 0.25, 'x[6] <= 54.5\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", " Text(0.3816556548775748, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.38787407695297316, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.3816556548775748, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 13\\nvalue = 6.0'),\n", " Text(0.4049747376603187, 0.5277777777777778, 'x[3] <= 3.05\\nsquared_error = 0.397\\nsamples = 36\\nvalue = 6.139'),\n", " Text(0.39720171006607075, 0.4722222222222222, 'x[1] <= 0.412\\nsquared_error = 0.333\\nsamples = 30\\nvalue = 6.0'),\n", " Text(0.3909832879906724, 0.4166666666666667, 'x[10] <= 10.15\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 6.5'),\n", " Text(0.38787407695297316, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", " Text(0.39409249902837157, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.4034201321414691, 0.4166666666666667, 'x[5] <= 3.5\\nsquared_error = 0.24\\nsamples = 22\\nvalue = 5.818'),\n", " Text(0.4003109211037699, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.4065293431791683, 0.3611111111111111, 'x[2] <= 0.465\\nsquared_error = 0.181\\nsamples = 21\\nvalue = 5.762'),\n", " Text(0.4003109211037699, 0.3055555555555556, 'x[9] <= 1.09\\nsquared_error = 0.109\\nsamples = 16\\nvalue = 5.875'),\n", " Text(0.39720171006607075, 0.25, 'x[8] <= 3.49\\nsquared_error = 0.062\\nsamples = 15\\nvalue = 5.933'),\n", " Text(0.39409249902837157, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 14\\nvalue = 6.0'),\n", " Text(0.4003109211037699, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4034201321414691, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.41274776525456663, 0.3055555555555556, 'x[1] <= 0.455\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.4'),\n", " Text(0.40963855421686746, 0.25, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.4158569762922658, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.41274776525456663, 0.4722222222222222, 'x[5] <= 16.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", " Text(0.40963855421686746, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", " Text(0.4158569762922658, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.4205207928488146, 0.6388888888888888, 'x[2] <= 0.25\\nsquared_error = 1.04\\nsamples = 5\\nvalue = 4.6'),\n", " Text(0.41430237077341625, 0.5833333333333334, 'x[5] <= 41.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.4111931597357171, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.41741158181111543, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.42673921492421296, 0.5833333333333334, 'x[4] <= 0.146\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 3.5'),\n", " Text(0.4236300038865138, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", " Text(0.42984842596191214, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.4422852701127089, 0.6944444444444444, 'x[9] <= 0.635\\nsquared_error = 0.407\\nsamples = 22\\nvalue = 4.955'),\n", " Text(0.43606684803731055, 0.6388888888888888, 'x[10] <= 9.975\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 3.667'),\n", " Text(0.4329576369996114, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 3.0'),\n", " Text(0.43917605907500973, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.44850369218810726, 0.6388888888888888, 'x[9] <= 0.875\\nsquared_error = 0.133\\nsamples = 19\\nvalue = 5.158'),\n", " Text(0.4453944811504081, 0.5833333333333334, 'x[7] <= 0.995\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 5.059'),\n", " Text(0.4422852701127089, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.44850369218810726, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 16\\nvalue = 5.0'),\n", " Text(0.45161290322580644, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.4893120870579091, 0.75, 'x[6] <= 105.5\\nsquared_error = 0.245\\nsamples = 145\\nvalue = 5.228'),\n", " Text(0.4760979401476875, 0.6944444444444444, 'x[10] <= 10.35\\nsquared_error = 0.286\\nsamples = 106\\nvalue = 5.302'),\n", " Text(0.46832491255343955, 0.6388888888888888, 'x[1] <= 0.855\\nsquared_error = 0.27\\nsamples = 94\\nvalue = 5.245'),\n", " Text(0.4621064904780412, 0.5833333333333334, 'x[4] <= 0.539\\nsquared_error = 0.245\\nsamples = 90\\nvalue = 5.278'),\n", " Text(0.458997279440342, 0.5277777777777778, 'x[5] <= 18.5\\nsquared_error = 0.229\\nsamples = 89\\nvalue = 5.292'),\n", " Text(0.4407306645938593, 0.4722222222222222, 'x[9] <= 0.75\\nsquared_error = 0.245\\nsamples = 35\\nvalue = 5.429'),\n", " Text(0.43451224251846093, 0.4166666666666667, 'x[6] <= 91.5\\nsquared_error = 0.248\\nsamples = 24\\nvalue = 5.542'),\n", " Text(0.43140303148076176, 0.3611111111111111, 'x[5] <= 13.0\\nsquared_error = 0.227\\nsamples = 20\\nvalue = 5.65'),\n", " Text(0.4251846094053634, 0.3055555555555556, 'x[3] <= 2.05\\nsquared_error = 0.234\\nsamples = 8\\nvalue = 5.375'),\n", " Text(0.4220753983676642, 0.25, 'x[5] <= 10.5\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.75'),\n", " Text(0.41896618732996505, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.4251846094053634, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4282938204430626, 0.25, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", " Text(0.4376214535561601, 0.3055555555555556, 'x[3] <= 1.7\\nsquared_error = 0.139\\nsamples = 12\\nvalue = 5.833'),\n", " Text(0.43451224251846093, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4407306645938593, 0.25, 'x[8] <= 3.54\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 5.909'),\n", " Text(0.4376214535561601, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", " Text(0.44383987563155847, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4376214535561601, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", " Text(0.4469490866692577, 0.4166666666666667, 'x[8] <= 2.95\\nsquared_error = 0.149\\nsamples = 11\\nvalue = 5.182'),\n", " Text(0.44383987563155847, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.4500582977069569, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", " Text(0.4772638942868247, 0.4722222222222222, 'x[10] <= 9.55\\nsquared_error = 0.199\\nsamples = 54\\nvalue = 5.204'),\n", " Text(0.4640497473766032, 0.4166666666666667, 'x[10] <= 9.45\\nsquared_error = 0.226\\nsamples = 32\\nvalue = 5.344'),\n", " Text(0.45627671978235523, 0.3611111111111111, 'x[7] <= 1.003\\nsquared_error = 0.094\\nsamples = 19\\nvalue = 5.105'),\n", " Text(0.45316750874465606, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 17\\nvalue = 5.0'),\n", " Text(0.4593859308200544, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.4718227749708511, 0.3611111111111111, 'x[4] <= 0.076\\nsquared_error = 0.213\\nsamples = 13\\nvalue = 5.692'),\n", " Text(0.46560435289545277, 0.3055555555555556, 'x[1] <= 0.405\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", " Text(0.4624951418577536, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.46871356393315194, 0.25, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.47804119704624953, 0.3055555555555556, 'x[0] <= 9.05\\nsquared_error = 0.099\\nsamples = 9\\nvalue = 5.889'),\n", " Text(0.47493198600855036, 0.25, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", " Text(0.4811504080839487, 0.25, 'x[1] <= 0.52\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.47804119704624953, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4842596191216479, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.49047804119704624, 0.4166666666666667, 'x[2] <= 0.435\\nsquared_error = 0.091\\nsamples = 22\\nvalue = 5.0'),\n", " Text(0.48736883015934707, 0.3611111111111111, 'x[0] <= 9.95\\nsquared_error = 0.045\\nsamples = 21\\nvalue = 5.048'),\n", " Text(0.4842596191216479, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 19\\nvalue = 5.0'),\n", " Text(0.49047804119704624, 0.3055555555555556, 'x[8] <= 3.2\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.48736883015934707, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.4935872522347454, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.4935872522347454, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.4652157015157404, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.4745433346288379, 0.5833333333333334, 'x[8] <= 3.285\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 4.5'),\n", " Text(0.47143412359113873, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.47765254566653714, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.4838709677419355, 0.6388888888888888, 'x[3] <= 5.5\\nsquared_error = 0.188\\nsamples = 12\\nvalue = 5.75'),\n", " Text(0.4807617567042363, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 9\\nvalue = 6.0'),\n", " Text(0.4869801787796347, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.5025262339681306, 0.6944444444444444, 'x[8] <= 2.985\\nsquared_error = 0.076\\nsamples = 39\\nvalue = 5.026'),\n", " Text(0.4963078118927322, 0.6388888888888888, 'x[3] <= 1.95\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", " Text(0.49319860085503303, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.4994170229304314, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.5087446560435289, 0.6388888888888888, 'x[3] <= 1.65\\nsquared_error = 0.027\\nsamples = 36\\nvalue = 4.972'),\n", " Text(0.5056354450058298, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.5118538670812282, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 35\\nvalue = 5.0'),\n", " Text(0.7811771278663039, 0.9166666666666666, 'x[9] <= 0.645\\nsquared_error = 0.741\\nsamples = 490\\nvalue = 6.088'),\n", " Text(0.6395922652302759, 0.9444444444444444, ' False'),\n", " Text(0.6822046249514185, 0.8611111111111112, 'x[1] <= 1.015\\nsquared_error = 0.726\\nsamples = 215\\nvalue = 5.712'),\n", " Text(0.6318013991449669, 0.8055555555555556, 'x[10] <= 11.45\\nsquared_error = 0.583\\nsamples = 206\\nvalue = 5.791'),\n", " Text(0.5764671589584143, 0.75, 'x[1] <= 0.635\\nsquared_error = 0.527\\nsamples = 108\\nvalue = 5.528'),\n", " Text(0.5524679362611737, 0.6944444444444444, 'x[8] <= 3.475\\nsquared_error = 0.439\\nsamples = 70\\nvalue = 5.7'),\n", " Text(0.5378935095219588, 0.6388888888888888, 'x[4] <= 0.067\\nsquared_error = 0.427\\nsamples = 60\\nvalue = 5.8'),\n", " Text(0.5180722891566265, 0.5833333333333334, 'x[4] <= 0.059\\nsquared_error = 0.61\\nsamples = 10\\nvalue = 6.3'),\n", " Text(0.5118538670812282, 0.5277777777777778, 'x[9] <= 0.53\\nsquared_error = 0.25\\nsamples = 4\\nvalue = 5.5'),\n", " Text(0.5087446560435289, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.5149630781189273, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.5242907112320249, 0.5277777777777778, 'x[8] <= 3.43\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", " Text(0.5211815001943257, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", " Text(0.5273999222697241, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.5577147298872911, 0.5833333333333334, 'x[9] <= 0.585\\nsquared_error = 0.33\\nsamples = 50\\nvalue = 5.7'),\n", " Text(0.5445005829770696, 0.5277777777777778, 'x[10] <= 11.05\\nsquared_error = 0.402\\nsamples = 26\\nvalue = 5.462'),\n", " Text(0.5336183443451225, 0.4722222222222222, 'x[10] <= 10.85\\nsquared_error = 0.277\\nsamples = 16\\nvalue = 5.188'),\n", " Text(0.5273999222697241, 0.4166666666666667, 'x[9] <= 0.525\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 5.571'),\n", " Text(0.5242907112320249, 0.3611111111111111, 'x[0] <= 8.25\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 5.25'),\n", " Text(0.5211815001943257, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.5273999222697241, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.5305091333074232, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.5398367664205208, 0.4166666666666667, 'x[2] <= 0.04\\nsquared_error = 0.099\\nsamples = 9\\nvalue = 4.889'),\n", " Text(0.5367275553828216, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.5429459774582199, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 8\\nvalue = 5.0'),\n", " Text(0.5553828216090168, 0.4722222222222222, 'x[0] <= 9.45\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 5.9'),\n", " Text(0.5522736105713175, 0.4166666666666667, 'x[9] <= 0.575\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 6.125'),\n", " Text(0.5491643995336184, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 7\\nvalue = 6.0'),\n", " Text(0.5553828216090168, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.5584920326467159, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.5709288767975126, 0.5277777777777778, 'x[3] <= 2.9\\nsquared_error = 0.123\\nsamples = 24\\nvalue = 5.958'),\n", " Text(0.5678196657598135, 0.4722222222222222, 'x[1] <= 0.34\\nsquared_error = 0.079\\nsamples = 23\\nvalue = 5.913'),\n", " Text(0.5647104547221142, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.5709288767975126, 0.4166666666666667, 'x[1] <= 0.61\\nsquared_error = 0.043\\nsamples = 22\\nvalue = 5.955'),\n", " Text(0.5678196657598135, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 20\\nvalue = 6.0'),\n", " Text(0.5740380878352118, 0.3611111111111111, 'x[8] <= 3.375\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.5709288767975126, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.577147298872911, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.5740380878352118, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.5670423630003887, 0.6388888888888888, 'x[7] <= 0.996\\nsquared_error = 0.09\\nsamples = 10\\nvalue = 5.1'),\n", " Text(0.5639331519626894, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 9\\nvalue = 5.0'),\n", " Text(0.5701515740380878, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.6004663816556549, 0.6944444444444444, 'x[5] <= 6.5\\nsquared_error = 0.535\\nsamples = 38\\nvalue = 5.211'),\n", " Text(0.5864749319860085, 0.6388888888888888, 'x[1] <= 0.81\\nsquared_error = 0.222\\nsamples = 12\\nvalue = 4.667'),\n", " Text(0.5802565099106102, 0.5833333333333334, 'x[6] <= 10.0\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 4.875'),\n", " Text(0.577147298872911, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.5833657209483094, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 7\\nvalue = 5.0'),\n", " Text(0.5926933540614069, 0.5833333333333334, 'x[7] <= 0.996\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 4.25'),\n", " Text(0.5895841430237078, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.5958025650991061, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", " Text(0.6144578313253012, 0.6388888888888888, 'x[6] <= 45.5\\nsquared_error = 0.479\\nsamples = 26\\nvalue = 5.462'),\n", " Text(0.6051301982122037, 0.5833333333333334, 'x[2] <= 0.08\\nsquared_error = 0.312\\nsamples = 16\\nvalue = 5.75'),\n", " Text(0.6020209871745045, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", " Text(0.6082394092499028, 0.5277777777777778, 'x[9] <= 0.505\\nsquared_error = 0.56\\nsamples = 5\\nvalue = 5.2'),\n", " Text(0.6051301982122037, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.6113486202876021, 0.4722222222222222, 'x[7] <= 0.996\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 4.667'),\n", " Text(0.6082394092499028, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.6144578313253012, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.6237854644383988, 0.5833333333333334, 'x[3] <= 3.0\\nsquared_error = 0.4\\nsamples = 10\\nvalue = 5.0'),\n", " Text(0.6206762534006995, 0.5277777777777778, 'x[8] <= 3.48\\nsquared_error = 0.188\\nsamples = 8\\nvalue = 5.25'),\n", " Text(0.6175670423630004, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.6237854644383988, 0.4722222222222222, 'x[5] <= 13.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", " Text(0.6206762534006995, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.6268946754760979, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.6268946754760979, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 4.0'),\n", " Text(0.6871356393315197, 0.75, 'x[1] <= 0.485\\nsquared_error = 0.483\\nsamples = 98\\nvalue = 6.082'),\n", " Text(0.6634279051690634, 0.6944444444444444, 'x[8] <= 3.275\\nsquared_error = 0.436\\nsamples = 50\\nvalue = 6.38'),\n", " Text(0.6502137582588419, 0.6388888888888888, 'x[0] <= 10.1\\nsquared_error = 0.38\\nsamples = 29\\nvalue = 6.586'),\n", " Text(0.6393315196268947, 0.5833333333333334, 'x[1] <= 0.245\\nsquared_error = 0.28\\nsamples = 23\\nvalue = 6.739'),\n", " Text(0.6362223085891955, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.6424407306645938, 0.5277777777777778, 'x[1] <= 0.32\\nsquared_error = 0.228\\nsamples = 20\\nvalue = 6.85'),\n", " Text(0.6362223085891955, 0.4722222222222222, 'x[0] <= 9.95\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 7.083'),\n", " Text(0.6331130975514964, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 11\\nvalue = 7.0'),\n", " Text(0.6393315196268947, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.6486591527399922, 0.4722222222222222, 'x[1] <= 0.4\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 6.5'),\n", " Text(0.6455499417022931, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.6517683637776914, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", " Text(0.661095996890789, 0.5833333333333334, 'x[2] <= 0.72\\nsquared_error = 0.333\\nsamples = 6\\nvalue = 6.0'),\n", " Text(0.6579867858530898, 0.5277777777777778, 'x[1] <= 0.265\\nsquared_error = 0.16\\nsamples = 5\\nvalue = 5.8'),\n", " Text(0.6548775748153906, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.661095996890789, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.6642052079284881, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.6766420520792849, 0.6388888888888888, 'x[3] <= 6.1\\nsquared_error = 0.372\\nsamples = 21\\nvalue = 6.095'),\n", " Text(0.6735328410415857, 0.5833333333333334, 'x[0] <= 5.8\\nsquared_error = 0.16\\nsamples = 20\\nvalue = 6.2'),\n", " Text(0.6704236300038865, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.6766420520792849, 0.5277777777777778, 'x[3] <= 5.25\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.111'),\n", " Text(0.6735328410415857, 0.4722222222222222, 'x[6] <= 9.5\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.059'),\n", " Text(0.6704236300038865, 0.4166666666666667, 'x[4] <= 0.066\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", " Text(0.6673144189661874, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.6735328410415857, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.6766420520792849, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", " Text(0.6797512631169841, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.6797512631169841, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.7108433734939759, 0.6944444444444444, 'x[4] <= 0.058\\nsquared_error = 0.343\\nsamples = 48\\nvalue = 5.771'),\n", " Text(0.6984065293431791, 0.6388888888888888, 'x[1] <= 0.68\\nsquared_error = 0.373\\nsamples = 15\\nvalue = 5.4'),\n", " Text(0.6921881072677808, 0.5833333333333334, 'x[6] <= 102.5\\nsquared_error = 0.25\\nsamples = 8\\nvalue = 5.0'),\n", " Text(0.6890788962300817, 0.5277777777777778, 'x[2] <= 0.03\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 4.857'),\n", " Text(0.6859696851923824, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.6921881072677808, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 6\\nvalue = 5.0'),\n", " Text(0.69529731830548, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.7046249514185775, 0.5833333333333334, 'x[3] <= 2.45\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 5.857'),\n", " Text(0.7015157403808784, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", " Text(0.7077341624562767, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.7232802176447727, 0.6388888888888888, 'x[10] <= 12.85\\nsquared_error = 0.239\\nsamples = 33\\nvalue = 5.939'),\n", " Text(0.7201710066070734, 0.5833333333333334, 'x[9] <= 0.525\\nsquared_error = 0.194\\nsamples = 31\\nvalue = 6.0'),\n", " Text(0.7139525845316751, 0.5277777777777778, 'x[9] <= 0.515\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 5.5'),\n", " Text(0.7108433734939759, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.7170617955693742, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 5.0'),\n", " Text(0.7263894286824718, 0.5277777777777778, 'x[4] <= 0.059\\nsquared_error = 0.106\\nsamples = 25\\nvalue = 6.12'),\n", " Text(0.7232802176447727, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.729498639720171, 0.4722222222222222, 'x[5] <= 4.0\\nsquared_error = 0.076\\nsamples = 24\\nvalue = 6.083'),\n", " Text(0.7263894286824718, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.7326078507578702, 0.4166666666666667, 'x[4] <= 0.091\\nsquared_error = 0.042\\nsamples = 23\\nvalue = 6.043'),\n", " Text(0.729498639720171, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 20\\nvalue = 6.0'),\n", " Text(0.7357170617955694, 0.3611111111111111, 'x[6] <= 15.5\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.333'),\n", " Text(0.7326078507578702, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.7388262728332685, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.7263894286824718, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.7326078507578702, 0.8055555555555556, 'x[3] <= 1.9\\nsquared_error = 0.543\\nsamples = 9\\nvalue = 3.889'),\n", " Text(0.729498639720171, 0.75, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.7357170617955694, 0.75, 'x[2] <= 0.04\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 3.571'),\n", " Text(0.7326078507578702, 0.6944444444444444, 'x[0] <= 6.85\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 3.25'),\n", " Text(0.729498639720171, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.7357170617955694, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 3.0'),\n", " Text(0.7388262728332685, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 3\\nvalue = 4.0'),\n", " Text(0.8801496307811892, 0.8611111111111112, 'x[10] <= 11.55\\nsquared_error = 0.556\\nsamples = 275\\nvalue = 6.382'),\n", " Text(0.8251068791294209, 0.8055555555555556, 'x[1] <= 0.395\\nsquared_error = 0.559\\nsamples = 158\\nvalue = 6.171'),\n", " Text(0.7784687135639331, 0.75, 'x[8] <= 3.255\\nsquared_error = 0.605\\nsamples = 73\\nvalue = 6.466'),\n", " Text(0.7481539059463661, 0.6944444444444444, 'x[9] <= 0.705\\nsquared_error = 0.37\\nsamples = 31\\nvalue = 6.871'),\n", " Text(0.7419354838709677, 0.6388888888888888, 'x[4] <= 0.079\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 7.5'),\n", " Text(0.7388262728332685, 0.5833333333333334, 'x[10] <= 10.8\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 7.75'),\n", " Text(0.7357170617955694, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.7419354838709677, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 8.0'),\n", " Text(0.7450446949086669, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.7543723280217645, 0.6388888888888888, 'x[7] <= 0.995\\nsquared_error = 0.282\\nsamples = 25\\nvalue = 6.72'),\n", " Text(0.7512631169840653, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.7574815390594637, 0.5833333333333334, 'x[2] <= 0.345\\nsquared_error = 0.222\\nsamples = 24\\nvalue = 6.667'),\n", " Text(0.7543723280217645, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.7605907500971628, 0.5277777777777778, 'x[1] <= 0.375\\nsquared_error = 0.181\\nsamples = 21\\nvalue = 6.762'),\n", " Text(0.7574815390594637, 0.4722222222222222, 'x[10] <= 11.3\\nsquared_error = 0.133\\nsamples = 19\\nvalue = 6.842'),\n", " Text(0.7543723280217645, 0.4166666666666667, 'x[5] <= 23.5\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.889'),\n", " Text(0.7512631169840653, 0.3611111111111111, 'x[9] <= 1.055\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.941'),\n", " Text(0.7481539059463661, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 16\\nvalue = 7.0'),\n", " Text(0.7543723280217645, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.7574815390594637, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.7605907500971628, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.763699961134862, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.8087835211815002, 0.6944444444444444, 'x[6] <= 52.0\\nsquared_error = 0.567\\nsamples = 42\\nvalue = 6.167'),\n", " Text(0.7916828604741547, 0.6388888888888888, 'x[2] <= 0.47\\nsquared_error = 0.444\\nsamples = 28\\nvalue = 6.357'),\n", " Text(0.779246016323358, 0.5833333333333334, 'x[7] <= 0.994\\nsquared_error = 0.349\\nsamples = 18\\nvalue = 6.611'),\n", " Text(0.7730275942479595, 0.5277777777777778, 'x[1] <= 0.185\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.667'),\n", " Text(0.7699183832102604, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.7761368052856588, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.7854644383987563, 0.5277777777777778, 'x[2] <= 0.335\\nsquared_error = 0.16\\nsamples = 15\\nvalue = 6.8'),\n", " Text(0.7823552273610571, 0.4722222222222222, 'x[1] <= 0.315\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 6.4'),\n", " Text(0.779246016323358, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.7854644383987563, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.7885736494364555, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 10\\nvalue = 7.0'),\n", " Text(0.8041197046249514, 0.5833333333333334, 'x[10] <= 10.65\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 5.9'),\n", " Text(0.7979012825495531, 0.5277777777777778, 'x[7] <= 0.997\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.7947920715118538, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8010104935872522, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.8103381267003498, 0.5277777777777778, 'x[5] <= 5.5\\nsquared_error = 0.122\\nsamples = 7\\nvalue = 6.143'),\n", " Text(0.8072289156626506, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.813447337738049, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", " Text(0.8258841818888457, 0.6388888888888888, 'x[0] <= 8.05\\nsquared_error = 0.597\\nsamples = 14\\nvalue = 5.786'),\n", " Text(0.8196657598134474, 0.5833333333333334, 'x[10] <= 11.35\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", " Text(0.8165565487757481, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.8227749708511465, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8321026039642441, 0.5833333333333334, 'x[2] <= 0.56\\nsquared_error = 0.438\\nsamples = 8\\nvalue = 6.25'),\n", " Text(0.8289933929265448, 0.5277777777777778, 'x[1] <= 0.345\\nsquared_error = 0.245\\nsamples = 7\\nvalue = 6.429'),\n", " Text(0.8258841818888457, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", " Text(0.8321026039642441, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 6.0'),\n", " Text(0.8352118150019433, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.8717450446949087, 0.75, 'x[4] <= 0.093\\nsquared_error = 0.381\\nsamples = 85\\nvalue = 5.918'),\n", " Text(0.8585308977846872, 0.6944444444444444, 'x[6] <= 73.5\\nsquared_error = 0.279\\nsamples = 68\\nvalue = 6.015'),\n", " Text(0.8507578701904391, 0.6388888888888888, 'x[10] <= 11.45\\nsquared_error = 0.235\\nsamples = 62\\nvalue = 6.081'),\n", " Text(0.8445394481150408, 0.5833333333333334, 'x[4] <= 0.09\\nsquared_error = 0.206\\nsamples = 58\\nvalue = 6.034'),\n", " Text(0.8414302370773417, 0.5277777777777778, 'x[8] <= 3.57\\nsquared_error = 0.179\\nsamples = 56\\nvalue = 6.0'),\n", " Text(0.8383210260396424, 0.4722222222222222, 'x[10] <= 10.575\\nsquared_error = 0.147\\nsamples = 54\\nvalue = 5.963'),\n", " Text(0.8352118150019433, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.8414302370773417, 0.4166666666666667, 'x[7] <= 1.0\\nsquared_error = 0.129\\nsamples = 53\\nvalue = 5.943'),\n", " Text(0.8328799067236689, 0.3611111111111111, 'x[2] <= 0.29\\nsquared_error = 0.104\\nsamples = 48\\nvalue = 5.979'),\n", " Text(0.8251068791294209, 0.3055555555555556, 'x[6] <= 36.5\\nsquared_error = 0.09\\nsamples = 30\\nvalue = 5.9'),\n", " Text(0.8219976680917217, 0.25, 'x[0] <= 7.7\\nsquared_error = 0.152\\nsamples = 16\\nvalue = 5.812'),\n", " Text(0.8157792460163233, 0.19444444444444445, 'x[10] <= 10.7\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 5.923'),\n", " Text(0.8126700349786242, 0.1388888888888889, 'x[7] <= 0.995\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 5.5'),\n", " Text(0.809560823940925, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8157792460163233, 0.08333333333333333, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.8188884570540226, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 11\\nvalue = 6.0'),\n", " Text(0.8282160901671201, 0.19444444444444445, 'x[1] <= 0.762\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 5.333'),\n", " Text(0.8251068791294209, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.8313253012048193, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8282160901671201, 0.25, 'squared_error = 0.0\\nsamples = 14\\nvalue = 6.0'),\n", " Text(0.8406529343179169, 0.3055555555555556, 'x[2] <= 0.315\\nsquared_error = 0.099\\nsamples = 18\\nvalue = 6.111'),\n", " Text(0.8375437232802176, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.843762145355616, 0.25, 'x[7] <= 0.996\\nsquared_error = 0.055\\nsamples = 17\\nvalue = 6.059'),\n", " Text(0.8406529343179169, 0.19444444444444445, 'x[4] <= 0.076\\nsquared_error = 0.25\\nsamples = 2\\nvalue = 6.5'),\n", " Text(0.8375437232802176, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.843762145355616, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8468713563933152, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 15\\nvalue = 6.0'),\n", " Text(0.8499805674310144, 0.3611111111111111, 'x[7] <= 1.0\\nsquared_error = 0.24\\nsamples = 5\\nvalue = 5.6'),\n", " Text(0.8468713563933152, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.8530897784687136, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.8445394481150408, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.84764865915274, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.8569762922658375, 0.5833333333333334, 'x[0] <= 10.05\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 6.75'),\n", " Text(0.8538670812281384, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", " Text(0.8600855033035367, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8663039253789351, 0.6388888888888888, 'x[9] <= 0.69\\nsquared_error = 0.222\\nsamples = 6\\nvalue = 5.333'),\n", " Text(0.863194714341236, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.8694131364166343, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 4\\nvalue = 5.0'),\n", " Text(0.8849591916051301, 0.6944444444444444, 'x[10] <= 11.15\\nsquared_error = 0.602\\nsamples = 17\\nvalue = 5.529'),\n", " Text(0.8787407695297318, 0.6388888888888888, 'x[0] <= 8.0\\nsquared_error = 0.286\\nsamples = 7\\nvalue = 5.0'),\n", " Text(0.8756315584920327, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 4.0'),\n", " Text(0.881849980567431, 0.5833333333333334, 'x[5] <= 7.5\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 5.167'),\n", " Text(0.8787407695297318, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.8849591916051301, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 5.0'),\n", " Text(0.8911776136805286, 0.6388888888888888, 'x[6] <= 18.0\\nsquared_error = 0.49\\nsamples = 10\\nvalue = 5.9'),\n", " Text(0.8880684026428294, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 2\\nvalue = 5.0'),\n", " Text(0.8942868247182277, 0.5833333333333334, 'x[1] <= 0.782\\nsquared_error = 0.359\\nsamples = 8\\nvalue = 6.125'),\n", " Text(0.8911776136805286, 0.5277777777777778, 'x[8] <= 3.055\\nsquared_error = 0.204\\nsamples = 7\\nvalue = 6.286'),\n", " Text(0.8880684026428294, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.8942868247182277, 0.4722222222222222, 'x[4] <= 0.119\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.167'),\n", " Text(0.8911776136805286, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.897396035755927, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.897396035755927, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.9351923824329577, 0.8055555555555556, 'x[7] <= 0.993\\nsquared_error = 0.41\\nsamples = 117\\nvalue = 6.667'),\n", " Text(0.9036144578313253, 0.75, 'x[1] <= 0.4\\nsquared_error = 0.438\\nsamples = 13\\nvalue = 7.154'),\n", " Text(0.9005052467936261, 0.6944444444444444, 'squared_error = 0.0\\nsamples = 2\\nvalue = 6.0'),\n", " Text(0.9067236688690244, 0.6944444444444444, 'x[0] <= 5.45\\nsquared_error = 0.231\\nsamples = 11\\nvalue = 7.364'),\n", " Text(0.9036144578313253, 0.6388888888888888, 'x[4] <= 0.054\\nsquared_error = 0.109\\nsamples = 8\\nvalue = 7.125'),\n", " Text(0.9005052467936261, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 7\\nvalue = 7.0'),\n", " Text(0.9067236688690244, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.9098328799067237, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 3\\nvalue = 8.0'),\n", " Text(0.96677030703459, 0.75, 'x[6] <= 56.5\\nsquared_error = 0.373\\nsamples = 104\\nvalue = 6.606'),\n", " Text(0.9397590361445783, 0.6944444444444444, 'x[9] <= 0.685\\nsquared_error = 0.352\\nsamples = 90\\nvalue = 6.678'),\n", " Text(0.9191605130198213, 0.6388888888888888, 'x[6] <= 17.5\\nsquared_error = 0.216\\nsamples = 19\\nvalue = 6.316'),\n", " Text(0.9129420909444228, 0.5833333333333334, 'x[1] <= 0.328\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.833'),\n", " Text(0.9098328799067237, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.916051301982122, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 5\\nvalue = 7.0'),\n", " Text(0.9253789350952196, 0.5833333333333334, 'x[3] <= 5.05\\nsquared_error = 0.071\\nsamples = 13\\nvalue = 6.077'),\n", " Text(0.9222697240575204, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 12\\nvalue = 6.0'),\n", " Text(0.9284881461329187, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.9603575592693354, 0.6388888888888888, 'x[10] <= 12.45\\nsquared_error = 0.344\\nsamples = 71\\nvalue = 6.775'),\n", " Text(0.9455888068402643, 0.5833333333333334, 'x[6] <= 34.5\\nsquared_error = 0.304\\nsamples = 50\\nvalue = 6.66'),\n", " Text(0.9347065682083171, 0.5277777777777778, 'x[5] <= 5.5\\nsquared_error = 0.228\\nsamples = 36\\nvalue = 6.778'),\n", " Text(0.9284881461329187, 0.4722222222222222, 'x[6] <= 10.0\\nsquared_error = 0.139\\nsamples = 6\\nvalue = 6.167'),\n", " Text(0.9253789350952196, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.931597357170618, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 5\\nvalue = 6.0'),\n", " Text(0.9409249902837155, 0.4722222222222222, 'x[9] <= 0.695\\nsquared_error = 0.157\\nsamples = 30\\nvalue = 6.9'),\n", " Text(0.9378157792460163, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.9440342013214147, 0.4166666666666667, 'x[3] <= 1.65\\nsquared_error = 0.119\\nsamples = 29\\nvalue = 6.862'),\n", " Text(0.9409249902837155, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.9471434123591139, 0.3611111111111111, 'x[4] <= 0.053\\nsquared_error = 0.096\\nsamples = 28\\nvalue = 6.893'),\n", " Text(0.9440342013214147, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.950252623396813, 0.3055555555555556, 'x[4] <= 0.161\\nsquared_error = 0.069\\nsamples = 27\\nvalue = 6.926'),\n", " Text(0.9471434123591139, 0.25, 'x[7] <= 0.998\\nsquared_error = 0.037\\nsamples = 26\\nvalue = 6.962'),\n", " Text(0.9440342013214147, 0.19444444444444445, 'squared_error = 0.0\\nsamples = 22\\nvalue = 7.0'),\n", " Text(0.950252623396813, 0.19444444444444445, 'x[7] <= 0.998\\nsquared_error = 0.188\\nsamples = 4\\nvalue = 6.75'),\n", " Text(0.9471434123591139, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.9533618344345123, 0.1388888888888889, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", " Text(0.9533618344345123, 0.25, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.9564710454722114, 0.5277777777777778, 'x[6] <= 47.0\\nsquared_error = 0.372\\nsamples = 14\\nvalue = 6.357'),\n", " Text(0.9533618344345123, 0.4722222222222222, 'x[4] <= 0.06\\nsquared_error = 0.29\\nsamples = 10\\nvalue = 6.1'),\n", " Text(0.950252623396813, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.9564710454722114, 0.4166666666666667, 'x[3] <= 2.35\\nsquared_error = 0.173\\nsamples = 9\\nvalue = 6.222'),\n", " Text(0.9533618344345123, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 6\\nvalue = 6.0'),\n", " Text(0.9595802565099106, 0.3611111111111111, 'x[5] <= 19.0\\nsquared_error = 0.222\\nsamples = 3\\nvalue = 6.667'),\n", " Text(0.9564710454722114, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0'),\n", " Text(0.9626894675476098, 0.3055555555555556, 'squared_error = 0.0\\nsamples = 1\\nvalue = 6.0'),\n", " Text(0.9595802565099106, 0.4722222222222222, 'squared_error = 0.0\\nsamples = 4\\nvalue = 7.0'),\n", " Text(0.9751263116984066, 0.5833333333333334, 'x[9] <= 0.695\\nsquared_error = 0.331\\nsamples = 21\\nvalue = 7.048'),\n", " Text(0.9720171006607073, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 2\\nvalue = 8.0'),\n", " Text(0.9782355227361057, 0.5277777777777778, 'x[0] <= 8.75\\nsquared_error = 0.26\\nsamples = 19\\nvalue = 6.947'),\n", " Text(0.9720171006607073, 0.4722222222222222, 'x[9] <= 0.85\\nsquared_error = 0.13\\nsamples = 13\\nvalue = 7.154'),\n", " Text(0.9689078896230081, 0.4166666666666667, 'x[6] <= 44.0\\nsquared_error = 0.076\\nsamples = 12\\nvalue = 7.083'),\n", " Text(0.965798678585309, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 11\\nvalue = 7.0'),\n", " Text(0.9720171006607073, 0.3611111111111111, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.9751263116984066, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 1\\nvalue = 8.0'),\n", " Text(0.9844539448115041, 0.4722222222222222, 'x[5] <= 8.5\\nsquared_error = 0.25\\nsamples = 6\\nvalue = 6.5'),\n", " Text(0.9813447337738049, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 6.0'),\n", " Text(0.9875631558492033, 0.4166666666666667, 'squared_error = 0.0\\nsamples = 3\\nvalue = 7.0'),\n", " Text(0.9937815779246016, 0.6944444444444444, 'x[2] <= 0.69\\nsquared_error = 0.265\\nsamples = 14\\nvalue = 6.143'),\n", " Text(0.9906723668869024, 0.6388888888888888, 'x[10] <= 13.9\\nsquared_error = 0.167\\nsamples = 12\\nvalue = 6.0'),\n", " Text(0.9875631558492033, 0.5833333333333334, 'x[0] <= 9.15\\nsquared_error = 0.083\\nsamples = 11\\nvalue = 6.091'),\n", " Text(0.9844539448115041, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 10\\nvalue = 6.0'),\n", " Text(0.9906723668869024, 0.5277777777777778, 'squared_error = 0.0\\nsamples = 1\\nvalue = 7.0'),\n", " Text(0.9937815779246016, 0.5833333333333334, 'squared_error = 0.0\\nsamples = 1\\nvalue = 5.0'),\n", " Text(0.9968907889623008, 0.6388888888888888, 'squared_error = 0.0\\nsamples = 2\\nvalue = 7.0')]" ] }, "execution_count": 128, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "regressor = DecisionTreeRegressor()\n", "regressor.fit(X_train, y_train)\n", "tree.plot_tree(regressor)" ] }, { "cell_type": "code", "execution_count": 129, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Actual Predicted\n", "0 6 5.0\n", "1 5 6.0\n", "2 7 7.0\n", "3 6 5.0\n", "4 5 5.0\n", ".. ... ...\n", "315 6 6.0\n", "316 4 7.0\n", "317 5 5.0\n", "318 4 5.0\n", "319 6 7.0\n", "\n", "[320 rows x 2 columns]\n" ] } ], "source": [ "y_pred = regressor.predict(X_test)\n", "df = pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})\n", "print(df)" ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MSE: 0.709375\n", "MAE: 0.465625\n" ] }, { "data": { "text/plain": [ "8.261588715046605" ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print('MSE:', metrics.mean_squared_error(y_test, y_pred))\n", "print('MAE:', metrics.mean_absolute_error(y_test, y_pred))\n", "\n", "metrics.mean_absolute_error(y_test, y_pred) / np.average(y) * 100" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.0" } }, "nbformat": 4, "nbformat_minor": 2 }