diff --git "a/automl.ipynb" "b/automl.ipynb" new file mode 100644--- /dev/null +++ "b/automl.ipynb" @@ -0,0 +1,2289 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

1 | 模型介绍

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.1 算法简介" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "XGBoost(Extreme Gradient Boosting),即一种高效的梯度提升决策树算法。他在原有的GBDT基础上进行了改进，使得模型效果得到大大提升。作为一种前向加法模型，他的核心是采用集成思想——Boosting思想，将多个弱学习器通过一定的方法整合为一个强学习器。即用多棵树共同决策，并且用每棵树的结果都是目标值与之前所有树的预测结果之差 并将所有的结果累加即得到最终的结果，以此达到整个模型效果的提升。\n", + "\n", + "XGBoost是由多棵CART(Classification And Regression Tree)，即分类回归树组成，因此他可以处理分类回归等问题。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.2 数学原理\n", + "### 1.2.1 目标函数\n", + "\n", + "我们知道 XGBoost 是由 k 个基模型组成的一个加法运算式：\n", + "\n", + "$$\\hat{y}_i=\\sum_{t=1}^{k}\\ f_t(x_i) \\\\$$\n", + "\n", + "其中 $f_{k}$ 为第 k 个基模型， $\\hat{y}_i$ 为第 i 个样本的预测值。\n", + "\n", + "损失函数可由预测值 $\\hat{y}_i$ 与真实值 $y_i$ 进行表示：\n", + "\n", + "$$L=\\sum_{i=1}^n l( y_i, \\hat{y}_i) \\\\$$\n", + "\n", + "其中 n 为样本数量。\n", + "\n", + "我们知道模型的预测精度由模型的偏差和方差共同决定，损失函数代表了模型的偏差，想要方差小则需要简单的模型，所以目标函数由模型的损失函数 L 与抑制模型复杂度的正则项 $\\Omega$ 组成，所以我们有：\n", + "\n", + "$$Obj =\\sum_{i=1}^n l(\\hat{y}_i, y_i) + \\sum_{t=1}^k \\Omega(f_t) \\\\$$\n", + "\n", + "$\\Omega$ 为模型的正则项，由于 XGBoost 支持决策树也支持线性模型，所以这里再不展开描述。\n", + "\n", + "我们知道 boosting 模型是前向加法，以第 t 步的模型为例，模型对第 i 个样本 $x_{i}$ 的预测为：\n", + "\n", + "$$\\hat{y}_i^t= \\hat{y}_i^{t-1} + f_t(x_i) \\\\$$\n", + "\n", + "其中 $\\hat{y}_i^{t-1}$ 由第 t-1 步的模型给出的预测值，是已知常数，$f_t(x_i)$ 是我们这次需要加入的新模型的预测值，此时，目标函数就可以写成：\n", + "\n", + "$$\\begin{align} Obj^{(t)} &= \\sum_{i=1}^nl(y_i, \\hat{y}_i^t) + \\sum_{i=1}^t\\Omega(f_i) \\\\ &= \\sum_{i=1}^n l\\left(y_i, \\hat{y}_i^{t-1} + f_t(x_i) \\right) + \\sum_{i=1}^t \\Omega(f_i) \\end{align} \\\\$$\n", + "\n", + "求此时最优化目标函数，就相当于求解$f_t(x_i)$。\n", + "\n", + "泰勒公式是将一个在 $x=x_0$ 处具有 n 阶导数的函数 $f(x)$ 利用关于$ x-x_0 $的 n 次多项式来逼近函数的方法，若函数$ f(x) $在包含$ x_0 $的某个闭区间 $[a,b]$ 上具有 n 阶导数，且在开区间 $(a,b) $上具有 n+1 阶导数，则对闭区间$ [a,b] $上任意一点 x 有$ \\displaystyle f(x)=\\sum_{i=0}^{n}\\frac{f^{(i)}(x_0)}{i!}(x-x_0)^ i+R_n(x) $，其中的多项式称为函数在 $x_0 $处的泰勒展开式， $R_n(x)$ 是泰勒公式的余项且是 $(x−x_0)^n $的高阶无穷小。\n", + "根据泰勒公式我们把函数$f(x+\\Delta x)$ 在点 x 处进行泰勒的二阶展开，可得到如下等式：\n", + "\n", + "$$f(x+\\Delta x) \\approx f(x) + f'(x)\\Delta x + \\frac12 f''(x)\\Delta x^2 \\\\$$\n", + "\n", + "我们把 $\\hat{y}_i^{t-1}$ 视为 $x $， $f_t(x_i)$ 视为 $\\Delta x $，故可以将目标函数写为：\n", + "\n", + "$$Obj^{(t)} = \\sum_{i=1}^n \\left[ l(y_i, \\hat{y}_i^{t-1}) + g_if_t(x_i) + \\frac12h_if_t^2(x_i) \\right] + \\sum_{i=1}^t \\Omega(f_i) \\\\$$\n", + "\n", + "其中$ g_{i} $为损失函数的一阶导， $h_{i}$为损失函数的二阶导，注意这里的导是对 $\\hat{y}_i^{t-1}$ 求导。\n", + "\n", + "我们以平方损失函数为例：\n", + "\n", + "$$\\sum_{i=1}^n \\left(y_i - (\\hat{y}_i^{t-1} + f_t(x_i)) \\right)^2 \\\\$$\n", + "\n", + "则：\n", + "\n", + "$$\\begin{align} g_i &= \\frac{\\partial (\\hat{y}^{t-1} - y_i)^2}{\\partial {\\hat{y}^{t-1}}} = 2(\\hat{y}^{t-1} - y_i) \\\\ h_i &=\\frac{\\partial^2(\\hat{y}^{t-1} - y_i)^2}{{\\hat{y}^{t-1}}} = 2 \\end{align} \\\\$$\n", + "\n", + "由于在第 t 步时 $\\hat{y}_i^{t-1}$ 其实是一个已知的值，所以 $l(y_i, \\hat{y}_i^{t-1}) $是一个常数，其对函数的优化不会产生影响，因此目标函数可以写成：\n", + "\n", + "$$Obj^{(t)} \\approx \\sum_{i=1}^n \\left[ g_if_t(x_i) + \\frac12h_if_t^2(x_i) \\right] + \\sum_{i=1}^t \\Omega(f_i) \\\\$$\n", + "\n", + "所以我们只需要求出每一步损失函数的一阶导和二阶导���值（由于前一步的 $\\hat{y}^{t-1} $是已知的，所以这两个值就是常数），然后最优化目标函数，就可以得到每一步的$ f(x)$ ，最后根据加法模型得到一个整体模型。\n", + "\n", + "### 1.2.2 基于决策树的目标函数\n", + "\n", + "我们知道 Xgboost 的基模型不仅支持决策树，还支持线性模型，这里我们主要介绍基于决策树的目标函数。\n", + "\n", + "我们可以将决策树定义为 $f_t(x)=w_{q(x)}$ ， x 为某一样本，这里的 $q(x)$ 代表了该样本在哪个叶子结点上，而 $w_q $则代表了叶子结点取值 w ，所以$ w_{q(x)} $就代表了每个样本的取值 $w$ （即预测值）。\n", + "\n", + "决策树的复杂度可由叶子数$ T $组成，叶子节点越少模型越简单，此外叶子节点也不应该含有过高的权重 $w $（类比 LR 的每个变量的权重），所以目标函数的正则项可以定义为：\n", + "\n", + "$$\\Omega(f_t)=\\gamma T + \\frac12 \\lambda \\sum_{j=1}^T w_j^2 \\\\$$\n", + "\n", + "即决策树模型的复杂度由生成的所有决策树的叶子节点数量，和所有节点权重所组成的向量的 L_2 范式共同决定。\n", + "![图片](https://pic1.zhimg.com/v2-e0ab9287990a6098e4cdbc5a8cff4150_r.jpg)\n", + "\n", + "这张图给出了基于决策树的 XGBoost 的正则项的求解方式。\n", + "\n", + "我们设 $I_j= \\{ i \\vert q(x_i)=j \\}$ 为第 j 个叶子节点的样本集合，故我们的目标函数可以写成：\n", + "\n", + "$$\\begin{align} Obj^{(t)} &\\approx \\sum_{i=1}^n \\left[ g_if_t(x_i) + \\frac12h_if_t^2(x_i) \\right] + \\Omega(f_t) \\\\ &= \\sum_{i=1}^n \\left[ g_iw_{q(x_i)} + \\frac12h_iw_{q(x_i)}^2 \\right] + \\gamma T + \\frac12 \\lambda \\sum_{j=1}^Tw_j^2 \\\\ &= \\sum_{j=1}^T \\left[(\\sum_{i \\in I_j}g_i)w_j + \\frac12(\\sum_{i \\in I_j}h_i + \\lambda)w_j^2 \\right] + \\gamma T \\end{align} \\\\$$\n", + "\n", + "第二步到第三步可能看的不是特别明白，这边做些解释：第二步是遍历所有的样本后求每个样本的损失函数，但样本最终会落在叶子节点上，所以我们也可以遍历叶子节点，然后获取叶子节点上的样本集合，最后在求损失函数。即我们之前样本的集合，现在都改写成叶子结点的集合，由于一个叶子结点有多个样本存在，因此才有了 $\\sum_{i \\in I_j}g_i 和 \\sum_{i \\in I_j}h_i$ 这两项， $w_j$ 为第 j 个叶子节点取值。\n", + "\n", + "为简化表达式，我们定义 $G_j=\\sum_{i \\in I_j}g_i ， H_j=\\sum_{i \\in I_j}h_i$ ，则目标函数为：\n", + "\n", + "$$Obj^{(t)} = \\sum_{j=1}^T \\left[G_jw_j + \\frac12(H_j + \\lambda)w_j^2 \\right] + \\gamma T \\\\$$\n", + "\n", + "这里我们要注意$ G_j $和 $H_j$ 是前 t-1 步得到的结果，其值已知可视为常数，只有最后一棵树的叶子节点$ w_j $不确定，那么将目标函数对$ w_j $求一阶导，并令其等于 0 ，则可以求得叶子结点 j 对应的权值：\n", + "\n", + "$$w_j^*=-\\frac{G_j}{H_j+\\lambda} \\\\$$\n", + "\n", + "所以目标函数可以化简为：\n", + "\n", + "$$Obj = -\\frac12 \\sum_{j=1}^T \\frac{G_j^2}{H_j+\\lambda} + \\gamma T \\\\$$\n", + "\n", + "![图片](https://pic2.zhimg.com/v2-f6db7af6c1e683192cb0ccf48eafaf99_r.jpg)\n", + "\n", + "上图给出目标函数计算的例子，求每个节点每个样本的一阶导数 $g_i $和二阶导数$ h_i $，然后针对每个节点对所含样本求和得到的 $G_j $和 $H_j$ ，最后遍历决策树的节点即可得到目标函数。\n", + "\n", + "### 1.2.3 最优切分点划分算法\n", + "\n", + "在决策树的生长过程中，一个非常关键的问题是如何找到叶子的节点的最优切分点，Xgboost 支持两种分裂节点的方法——贪心算法和近似算法。\n", + "\n", + "1）贪心算法\n", + "\n", + "从深度为 0 的树开始，对每个叶节点枚举所有的可用特征；\n", + "针对每个特征，把属于该节点的训练样本根据该特征值进行升序排列，通过线性扫描的方式来决定该特征的最佳分裂点，并记录该特征的分裂收益；\n", + "选择收益最大的特征作为分裂特征，用该特征的最佳分裂点作为分裂位置，在该节点上分裂出左右两个新的叶节点，并为每个新节点关联对应的样本集\n", + "回到第 1 步，递归执行到满足特定条件为止\n", + "那么如何计算每个特征的分裂收益呢？\n", + "\n", + "假设我们在某一节点完成特征分裂，则分列前的目标函数可以写为：\n", + "\n", + "$$Obj_{1} =-\\frac12 [\\frac{(G_L+G_R)^2}{H_L+H_R+\\lambda}] + \\gamma \\\\$$\n", + "\n", + "分裂后的目标函数为：\n", + "\n", + "$$Obj_2 = -\\frac12 [ \\frac{G_L^2}{H_L+\\lambda} + \\frac{G_R^2}{H_R+\\lambda}] +2\\gamma \\\\$$\n", + "\n", + "则对于目标函数来说，分裂后的收益为：\n", + "\n", + "$$Gain=\\frac12 \\left[ \\frac{G_L^2}{H_L+\\lambda} + \\frac{G_R^2}{H_R+\\lambda} - \\frac{(G_L+G_R)^2}{H_L+H_R+\\lambda}\\right] - \\gamma \\\\$$\n", + "\n", + "注意该特征收益也可作为特征重要性输出的重要依据。\n", + "\n", + "对于每次分裂，我们都需要枚举所有特征可能的分割方案，如何高效地枚举所有的分割呢？\n", + "\n", + "我假设我们要枚举所有$ x < a$ 这样的条件，对于某个特定的分割点 a 我们要计算 a 左边和右边的导数和。\n", + "\n", + "\n", + "我们可以发现对于所有的分裂点 a ，我们只要做一遍从左到右的扫描就可以枚举出所有分割的梯度和 $G_L $和 $G_R$ 。然后用上面的公式计算每个分割方案的分数就可以了。\n", + "\n", + "观察分裂后的收益，我们会发现节点划分不一定会使得结果变好，因为我们有一个引入新叶子的惩罚项，也就是说引入的分割带来的增益如果小于一个阀值的时候，我们可以剪掉这个分割。\n", + "\n", + "2）近似算法\n", + "\n", + "贪婪算法可以的到最优解，但当数据量太大时则无法读入内存进行计算，近似算法主要针对贪婪算法这一缺点给出了近似最优解。\n", + "\n", + "对于每个特征，只考察分位点可以减少计算复杂度。\n", + "\n", + "该算法会首先根据特征分布的分位数提出候选划分点，然后将连续型特征映射到由这些候选点划分的桶中，然后聚合统计信息找到所有区间的最佳分裂点。\n", + "\n", + "在提出候选切分点时有两种策略：\n", + "\n", + "Global：学习每棵树前就提出候选切分点，并在每次分裂时都采用这种分割；\n", + "Local：每次分裂前将重新提出候选切分点。\n", + "直观上来看，Local 策略需要更多的计算步骤，而 Global 策略因为节点没有划分所以需要更多的候选点。\n", + "\n", + "下图给出不同种分裂策略的 AUC 变换曲线，横坐标为迭代次数，纵坐标为测试集 AUC，eps 为近似算法的精度，其倒数为桶的数量。\n", + "\n", + "\n", + "我们可以看到 Global 策略在候选点数多时（eps 小）可以和 Local 策略在候选点少时（eps 大）具有相似的精度。此外我们还发现，在 eps 取值合理的情况下，分位数策略可以获得与贪婪算法相同的精度。\n", + "\n", + "\n", + "第一个 for 循环：对特征 k 根据该特征分布的分位数找到切割点的候选集合 $S_k=\\{s_{k1},s_{k2},...,s_{kl} \\}$ 。XGBoost 支持 Global 策略和 Local 策略。\n", + "第二个 for 循环：针对每个特征的候选集合，将样本映射到由该特征对应的候选点集构成的分桶区间中，即 ${s_{k,v}≥x_{jk}>s_{k,v−1}}$ ，对每个桶统计 G,H 值，最后在这些统计量上寻找最佳分裂点。\n", + "下图给出近似算法的具体例子，以三分位为例：\n", + "\n", + "\n", + "根据样本特征进行排序，然后基于分位数进行划分，并统计三个桶内的 G,H 值，最终求解节点划分的增益。\n", + "\n", + "### 1.2.4 加权分位数缩略图\n", + "\n", + "事实上， XGBoost 不是简单地按照样本个数进行分位，而是以二阶导数值$ h_i $作为样本的权重进行划分，如下：\n", + "\n", + "\n", + "那么问题来了：为什么要用$ h_i$ 进行样本加权？\n", + "\n", + "我们知道模型的目标函数为：\n", + "\n", + "$$Obj^{(t)} \\approx \\sum_{i=1}^n \\left[ g_if_t(x_i) + \\frac12h_if_t^2(x_i) \\right] + \\sum_{i=1}^t \\Omega(f_i) \\\\$$\n", + "\n", + "我们稍作整理，便可以看出 $h_i$ 有对 loss 加权的作用。\n", + "\n", + "$$\\begin{align} Obj^{(t)} & \\approx \\sum_{i=1}^n \\left[ g_if_t(x_i) + \\frac12h_if_t^2(x_i) \\right] + \\sum_{i=1}^t \\Omega(f_i) \\\\ \\\\ &= \\sum_{i=1}^{n} [ g_i f_t(x_i) + \\frac{1}{2}h_i f_t^2(x_i) \\color{red}{+ \\frac{1}{2}\\frac{g_i^2}{h_i}}]+\\Omega(f_t) \\color{red}{+ C} \\\\ &= \\sum_{i=1}^{n} \\color{red}{\\frac{1}{2}h_i} \\left[ f_t(x_i) - \\left( -\\frac{g_i}{h_i} \\right) \\right]^2 + \\Omega(f_t) + C \\end{align} \\\\$$\n", + "\n", + "其中 $\\frac{1}{2}\\frac{g_i^2}{h_i}$ 与 C 皆为常数。我们可以看到 $h_i$ 就是平方损失函数中样本的权重。\n", + "\n", + "对于样本权值相同的数据集来说，找到候选分位点已经有了解决方案（GK 算法），但是当样本权值不一样时，该如何找到候选分位点呢？（作者给出了一个 Weighted Quantile Sketch 算法，这里将不做介绍。）\n", + "\n", + "### 1.2.5 稀疏感知算法\n", + "\n", + "在决策树的第一篇文章中我们介绍 CART 树在应对数据缺失时的分裂策略，XGBoost 也给出了其解决方案。\n", + "\n", + "XGBoost 在构建树的节点过程中只考虑非缺失值的数据遍历，而为每个节点增加了一个缺省方向，��样本相应的特征值缺失时，可以被归类到缺省方向上，最优的缺省方向可以从数据中学到。至于如何学到缺省值的分支，其实很简单，分别枚举特征缺省的样本归为左右分支后的增益，选择增益最大的枚举项即为最优缺省方向。\n", + "\n", + "在构建树的过程中需要枚举特征缺失的样本，乍一看该算法的计算量增加了一倍，但其实该算法在构建树的过程中只考虑了特征未缺失的样本遍历，而特征值缺失的样本无需遍历只需直接分配到左右节点，故算法所需遍历的样本量减少，下图可以看到稀疏感知算法比 basic 算法速度块了超过 50 倍。\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 任务分析：\n", + "\n", + "艺术品价格预测为回归问题，数据集中包含的信息为\n", + "1. 作品序号\n", + "2. 作品名称\n", + "3. 艺术家名称\n", + "4. 艺术家ID\n", + "5. 艺术家级别\n", + "6. 艺术品类型\n", + "7. 艺术品宽(cm)\n", + "8. 艺术品高(cm)\n", + "9. 艺术品价格信息\n", + "\n", + "#### 任务目标：\n", + "根据艺术家名称、艺术家ID、艺术家级别、艺术品类型、艺术品宽(cm)、艺术品高(cm)信息预测此件作品的价格。\n", + "\n", + "#### 数据预处理：\n", + "在预处理阶段需要将数据进行标准化处理，且使用0填充数值缺失信息。因为数据进行归一化后的均值就是0，也可以先使用均值填充缺失数据在进行归一化，预测标签**Prices**无需进行归一化或者标准化处理，模型采用的是XGBoost，损失函数采用均方根误差RMSE。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

2 | 导入所需库与数据集

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + "
Artist IDDateCatalogueDepartmentClassificationHeight (cm)Width (cm)Prices
011975.0Y国家级中国山水画50.050.04000.0
111975.0Y国家级中国山水画50.050.04000.0
211975.0Y国家级中国山水画50.050.04000.0
311975.0Y国家级中国山水画45.045.04000.0
411975.0Y国家级中国山水画45.045.04000.0
...........................
313211974.0Y国家级中国画100.0100.036000.0
314211974.0Y国家级中国画60.080.017280.0
315211974.0Y国家级中国画80.0100.028800.0
316211974.0Y国家级中国画80.0100.028800.0
317211974.0Y国家级中国画60.070.015120.0
\n", + "

318 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " Artist ID Date Catalogue Department Classification Height (cm) \\\n", + "0 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "1 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "2 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "3 1 1975.0 Y 国家级 中国山水画 45.0 \n", + "4 1 1975.0 Y 国家级 中国山水画 45.0 \n", + ".. ... ... ... ... ... ... \n", + "313 21 1974.0 Y 国家级 中国画 100.0 \n", + "314 21 1974.0 Y 国家级 中国画 60.0 \n", + "315 21 1974.0 Y 国家级 中国画 80.0 \n", + "316 21 1974.0 Y 国家级 中国画 80.0 \n", + "317 21 1974.0 Y 国家级 中国画 60.0 \n", + "\n", + " Width (cm) Prices \n", + "0 50.0 4000.0 \n", + "1 50.0 4000.0 \n", + "2 50.0 4000.0 \n", + "3 45.0 4000.0 \n", + "4 45.0 4000.0 \n", + ".. ... ... \n", + "313 100.0 36000.0 \n", + "314 80.0 17280.0 \n", + "315 100.0 28800.0 \n", + "316 100.0 28800.0 \n", + "317 70.0 15120.0 \n", + "\n", + "[318 rows x 8 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data = pd.read_csv(\"datasets/archive/artworks.csv\")\n", + "train_data = train_data.iloc[:, [2,4,7,8,9,10,12,16]]\n", + "train_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

3 | 数据处理与分析

" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Artist ID 0\n", + "Date 164\n", + "Catalogue 0\n", + "Department 0\n", + "Classification 0\n", + "Height (cm) 0\n", + "Width (cm) 0\n", + "Prices 0\n", + "dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + "
Artist IDDateCatalogueDepartmentClassificationHeight (cm)Width (cm)Prices
011975.0Y国家级中国山水画50.050.04000.0
111975.0Y国家级中国山水画50.050.04000.0
211975.0Y国家级中国山水画50.050.04000.0
311975.0Y国家级中国山水画45.045.04000.0
411975.0Y国家级中国山水画45.045.04000.0
\n", + "
" + ], + "text/plain": [ + " Artist ID Date Catalogue Department Classification Height (cm) \\\n", + "0 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "1 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "2 1 1975.0 Y 国家级 中国山水画 50.0 \n", + "3 1 1975.0 Y 国家级 中国山水画 45.0 \n", + "4 1 1975.0 Y 国家级 中国山水画 45.0 \n", + "\n", + " Width (cm) Prices \n", + "0 50.0 4000.0 \n", + "1 50.0 4000.0 \n", + "2 50.0 4000.0 \n", + "3 45.0 4000.0 \n", + "4 45.0 4000.0 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numeric_features = train_data.dtypes[train_data.dtypes != 'object'].index\n", + "object_features = train_data.dtypes[train_data.dtypes == 'object'].index\n", + "# 使用均值代替缺失值\n", + "average_values = train_data.mean(numeric_only=True)\n", + "train_ = train_data.drop(object_features, axis=1).fillna(average_values)\n", + "train_data[numeric_features] = train_\n", + "train_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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", + "
Artist IDDateCatalogueDepartmentClassificationHeight (cm)Width (cm)Prices
011975.000050.050.04000.0
111975.000050.050.04000.0
211975.000050.050.04000.0
311975.000045.045.04000.0
411975.000045.045.04000.0
...........................
313211974.0001100.0100.036000.0
314211974.000160.080.017280.0
315211974.000180.0100.028800.0
316211974.000180.0100.028800.0
317211974.000160.070.015120.0
\n", + "

318 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " Artist ID Date Catalogue Department Classification Height (cm) \\\n", + "0 1 1975.0 0 0 0 50.0 \n", + "1 1 1975.0 0 0 0 50.0 \n", + "2 1 1975.0 0 0 0 50.0 \n", + "3 1 1975.0 0 0 0 45.0 \n", + "4 1 1975.0 0 0 0 45.0 \n", + ".. ... ... ... ... ... ... \n", + "313 21 1974.0 0 0 1 100.0 \n", + "314 21 1974.0 0 0 1 60.0 \n", + "315 21 1974.0 0 0 1 80.0 \n", + "316 21 1974.0 0 0 1 80.0 \n", + "317 21 1974.0 0 0 1 60.0 \n", + "\n", + " Width (cm) Prices \n", + "0 50.0 4000.0 \n", + "1 50.0 4000.0 \n", + "2 50.0 4000.0 \n", + "3 45.0 4000.0 \n", + "4 45.0 4000.0 \n", + ".. ... ... \n", + "313 100.0 36000.0 \n", + "314 80.0 17280.0 \n", + "315 100.0 28800.0 \n", + "316 100.0 28800.0 \n", + "317 70.0 15120.0 \n", + "\n", + "[318 rows x 8 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import LabelEncoder\n", + "train_data[['Catalogue','Department',\"Classification\"]] = train_data[['Catalogue','Department',\"Classification\"]].apply(LabelEncoder().fit_transform)\n", + "train_data" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Artist ID 0\n", + "Date 0\n", + "Catalogue 0\n", + "Department 0\n", + "Classification 0\n", + "Height (cm) 0\n", + "Width (cm) 0\n", + "Prices 0\n", + "dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "corr_mat = train_data.drop(labels=[\"Catalogue\", \"Department\"], axis=1).corr()\n", + "plt.figure(figsize=(8,8), dpi=100)\n", + "sns.heatmap(corr_mat,annot=True, fmt=\".2f\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.pairplot(data=train_data.drop(labels=[\"Catalogue\", \"Department\"], axis=1), kind=\"reg\",diag_kind=\"kde\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

4 | 划分数据集并训练模型

" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "X = train_data.drop([\"Prices\"],axis=1)\n", + "y = train_data[\"Prices\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.1, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**训练模型**" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "from flaml import AutoML\n", + "automl = AutoML()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[flaml.automl: 08-14 10:21:47] {2444} INFO - task = regression\n", + "[flaml.automl: 08-14 10:21:47] {2446} INFO - Data split method: uniform\n", + "[flaml.automl: 08-14 10:21:47] {2449} INFO - Evaluation method: cv\n", + "[flaml.automl: 08-14 10:21:47] {2568} INFO - Minimizing error metric: rmse\n", + "[flaml.automl: 08-14 10:21:47] {2708} INFO - List of ML learners in AutoML Run: ['lgbm', 'rf', 'xgboost', 'extra_tree', 'xgb_limitdepth']\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 0, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3143} INFO - Estimated sufficient time budget=310s. Estimated necessary time budget=2s.\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.0s,\testimator lgbm's best error=86025.1854,\tbest estimator lgbm's best error=86025.1854\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 1, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.1s,\testimator lgbm's best error=86025.1854,\tbest estimator lgbm's best error=86025.1854\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 2, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.1s,\testimator lgbm's best error=79347.2802,\tbest estimator lgbm's best error=79347.2802\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 3, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.2s,\testimator xgboost's best error=92710.7567,\tbest estimator lgbm's best error=79347.2802\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 4, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.3s,\testimator extra_tree's best error=82093.6316,\tbest estimator lgbm's best error=79347.2802\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 5, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.3s,\testimator lgbm's best error=74797.5333,\tbest estimator lgbm's best error=74797.5333\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 6, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.3s,\testimator lgbm's best error=74797.5333,\tbest estimator lgbm's best error=74797.5333\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 7, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.4s,\testimator lgbm's best error=68255.1169,\tbest estimator lgbm's best error=68255.1169\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 8, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.4s,\testimator lgbm's best error=68255.1169,\tbest estimator lgbm's best error=68255.1169\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 9, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.4s,\testimator lgbm's best error=68255.1169,\tbest estimator lgbm's best error=68255.1169\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 10, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:47] {3190} INFO - at 0.5s,\testimator lgbm's best error=59485.7062,\tbest estimator lgbm's best error=59485.7062\n", + "[flaml.automl: 08-14 10:21:47] {3010} INFO - iteration 11, current learner rf\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.6s,\testimator rf's best error=86020.7742,\tbest estimator lgbm's best error=59485.7062\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 12, current learner rf\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.6s,\testimator rf's best error=73129.9352,\tbest estimator lgbm's best error=59485.7062\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 13, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.7s,\testimator xgboost's best error=92710.7567,\tbest estimator lgbm's best error=59485.7062\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 14, current learner rf\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.8s,\testimator rf's best error=73129.9352,\tbest estimator lgbm's best error=59485.7062\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 15, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.9s,\testimator extra_tree's best error=54551.8951,\tbest estimator extra_tree's best error=54551.8951\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 16, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 0.9s,\testimator lgbm's best error=59485.7062,\tbest estimator extra_tree's best error=54551.8951\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 17, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.0s,\testimator extra_tree's best error=54551.8951,\tbest estimator extra_tree's best error=54551.8951\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 18, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.0s,\testimator lgbm's best error=49227.6113,\tbest estimator lgbm's best error=49227.6113\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 19, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.1s,\testimator xgboost's best error=84284.3582,\tbest estimator lgbm's best error=49227.6113\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 20, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.2s,\testimator lgbm's best error=44684.1674,\tbest estimator lgbm's best error=44684.1674\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 21, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.2s,\testimator lgbm's best error=42479.9393,\tbest estimator lgbm's best error=42479.9393\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 22, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.3s,\testimator lgbm's best error=42479.9393,\tbest estimator lgbm's best error=42479.9393\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 23, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.3s,\testimator lgbm's best error=42479.9393,\tbest estimator lgbm's best error=42479.9393\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 24, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.4s,\testimator extra_tree's best error=48232.1347,\tbest estimator lgbm's best error=42479.9393\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 25, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:48] {3190} INFO - at 1.5s,\testimator extra_tree's best error=42018.6680,\tbest estimator extra_tree's best error=42018.6680\n", + "[flaml.automl: 08-14 10:21:48] {3010} INFO - iteration 26, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 1.6s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=42018.6680\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 27, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 1.7s,\testimator extra_tree's best error=42018.6680,\tbest estimator extra_tree's best error=42018.6680\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 28, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 1.8s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 29, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 1.9s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 30, current learner rf\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.0s,\testimator rf's best error=60381.4555,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 31, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.1s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 32, current learner rf\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.2s,\testimator rf's best error=60381.4555,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 33, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 34, current learner rf\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.4s,\testimator rf's best error=60381.4555,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 35, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:49] {3190} INFO - at 2.5s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:49] {3010} INFO - iteration 36, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 2.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 37, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 2.7s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 38, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 2.7s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 39, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 2.8s,\testimator xgboost's best error=70558.9659,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 40, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.0s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 41, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.1s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 42, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.1s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 43, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.2s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 44, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 45, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.4s,\testimator xgboost's best error=61667.6517,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 46, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:50] {3190} INFO - at 3.5s,\testimator xgboost's best error=61667.6517,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:50] {3010} INFO - iteration 47, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 3.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 48, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 3.6s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 49, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 3.7s,\testimator xgboost's best error=44048.1440,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 50, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 3.9s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 51, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 3.9s,\testimator xgboost's best error=44048.1440,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 52, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.0s,\testimator xgboost's best error=44048.1440,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 53, current learner rf\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.1s,\testimator rf's best error=60381.4555,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 54, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.2s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 55, current learner xgboost\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.3s,\testimator xgboost's best error=43974.7300,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 56, current learner rf\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.4s,\testimator rf's best error=60381.4555,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 57, current learner rf\n", + "[flaml.automl: 08-14 10:21:51] {3190} INFO - at 4.5s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:51] {3010} INFO - iteration 58, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 4.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 59, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 4.6s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 60, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 4.7s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 61, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 4.8s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 62, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 4.9s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 63, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.0s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 64, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.0s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 65, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.2s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 66, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 67, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 68, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.4s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 69, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:52] {3190} INFO - at 5.5s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:52] {3010} INFO - iteration 70, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 5.6s,\testimator xgb_limitdepth's best error=53651.5559,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 71, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 5.7s,\testimator xgb_limitdepth's best error=53651.5559,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 72, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 5.8s,\testimator xgb_limitdepth's best error=52976.3145,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 73, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 5.9s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 74, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 6.0s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 75, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 6.1s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 76, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 6.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 77, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 6.4s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 78, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:53] {3190} INFO - at 6.5s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:53] {3010} INFO - iteration 79, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 6.6s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 80, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 6.7s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 81, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 6.8s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 82, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 6.9s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 83, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.0s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 84, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.1s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 85, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.2s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 86, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.3s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 87, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.4s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 88, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:54] {3190} INFO - at 7.5s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:54] {3010} INFO - iteration 89, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 7.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 90, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 7.7s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 91, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 7.8s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 92, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 7.9s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 93, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.0s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 94, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.1s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 95, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.2s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 96, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.3s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 97, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.3s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 98, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:55] {3190} INFO - at 8.5s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:55] {3010} INFO - iteration 99, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 8.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 100, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 8.6s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 101, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 8.7s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 102, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 8.8s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 103, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 8.9s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 104, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.0s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 105, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.1s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 106, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.2s,\testimator extra_tree's best error=31602.3198,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 107, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.3s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=31602.3198\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 108, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 109, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:56] {3190} INFO - at 9.5s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:56] {3010} INFO - iteration 110, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 9.6s,\testimator xgb_limitdepth's best error=38151.8727,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 111, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 9.7s,\testimator lgbm's best error=42479.9393,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 112, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 9.8s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 113, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 9.9s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 114, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.0s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 115, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.0s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 116, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.1s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 117, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 118, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 119, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.3s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 120, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 121, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:57] {3190} INFO - at 10.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:57] {3010} INFO - iteration 122, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 10.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 123, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 10.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 124, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 10.8s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 125, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 10.9s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 126, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.0s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 127, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.0s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 128, current learner rf\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.2s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 129, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 130, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 131, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 132, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:58] {3190} INFO - at 11.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:58] {3010} INFO - iteration 133, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 11.6s,\testimator lgbm's best error=39938.6894,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 134, current learner rf\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 11.8s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 135, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 11.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 136, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 11.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 137, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 12.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 138, current learner lgbm\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 12.2s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 139, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 12.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 140, current learner rf\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 12.4s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 141, current learner extra_tree\n", + "[flaml.automl: 08-14 10:21:59] {3190} INFO - at 12.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:21:59] {3010} INFO - iteration 142, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 12.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 143, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 12.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 144, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 12.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 145, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 12.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 146, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 12.9s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 147, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 13.0s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 148, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 13.1s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 149, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:00] {3190} INFO - at 13.5s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:00] {3010} INFO - iteration 150, current learner rf\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 13.7s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 151, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 13.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 152, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 13.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 153, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 154, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.0s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 155, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.1s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 156, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.2s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 157, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 158, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 159, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:01] {3190} INFO - at 14.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:01] {3010} INFO - iteration 160, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 14.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 161, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 14.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 162, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 14.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 163, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 14.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 164, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 15.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 165, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 15.1s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 166, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 15.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 167, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 15.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 168, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:02] {3190} INFO - at 15.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:02] {3010} INFO - iteration 169, current learner rf\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 15.6s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 170, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 15.8s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 171, current learner rf\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 15.9s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 172, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 16.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 173, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 16.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 174, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 16.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 175, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 16.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 176, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:03] {3190} INFO - at 16.4s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:03] {3010} INFO - iteration 177, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 16.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 178, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 16.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 179, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 16.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 180, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 16.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 181, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 16.9s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 182, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 17.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 183, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 17.2s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 184, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 17.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 185, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 17.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 186, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:04] {3190} INFO - at 17.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:04] {3010} INFO - iteration 187, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 17.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 188, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 17.6s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 189, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 17.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 190, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 17.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 191, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 17.9s,\testimator xgboost's best error=43974.7300,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 192, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 18.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 193, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 18.1s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 194, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 18.2s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 195, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 18.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 196, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:05] {3190} INFO - at 18.4s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:05] {3010} INFO - iteration 197, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 18.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 198, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 18.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 199, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 18.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 200, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 18.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 201, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 19.1s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 202, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 19.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 203, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 19.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 204, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:06] {3190} INFO - at 19.5s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:06] {3010} INFO - iteration 205, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 19.6s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 206, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 19.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 207, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 19.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 208, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 209, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.1s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 210, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 211, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 212, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 213, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:07] {3190} INFO - at 20.5s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:07] {3010} INFO - iteration 214, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 20.6s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 215, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 20.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 216, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 20.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 217, current learner rf\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 21.0s,\testimator rf's best error=58080.7529,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 218, current learner rf\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 21.2s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 219, current learner rf\n", + "[flaml.automl: 08-14 10:22:08] {3190} INFO - at 21.4s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:08] {3010} INFO - iteration 220, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 21.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 221, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 21.6s,\testimator lgbm's best error=38992.8296,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 222, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 21.7s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 223, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 21.8s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 224, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 22.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 225, current learner rf\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 22.3s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 226, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 22.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 227, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:09] {3190} INFO - at 22.5s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:09] {3010} INFO - iteration 228, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 22.6s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 229, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 22.7s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 230, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 22.8s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 231, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.0s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 232, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.1s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 233, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.2s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 234, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.3s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 235, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.4s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 236, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:10] {3190} INFO - at 23.5s,\testimator extra_tree's best error=28624.4876,\tbest estimator extra_tree's best error=28624.4876\n", + "[flaml.automl: 08-14 10:22:10] {3010} INFO - iteration 237, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:11] {3190} INFO - at 23.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:11] {3010} INFO - iteration 238, current learner rf\n", + "[flaml.automl: 08-14 10:22:11] {3190} INFO - at 23.9s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:11] {3010} INFO - iteration 239, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:11] {3190} INFO - at 24.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:11] {3010} INFO - iteration 240, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:11] {3190} INFO - at 24.1s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:11] {3010} INFO - iteration 241, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 24.6s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 242, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 24.7s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 243, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 24.8s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 244, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 24.9s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 245, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 25.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 246, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 25.2s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 247, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 25.3s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 248, current learner rf\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 25.4s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 249, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:12] {3190} INFO - at 25.5s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:12] {3010} INFO - iteration 250, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 25.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 251, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 25.9s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 252, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 26.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 253, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 26.1s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 254, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 26.2s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 255, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 26.4s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 256, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:13] {3190} INFO - at 26.5s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:13] {3010} INFO - iteration 257, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 26.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 258, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 26.7s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 259, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 26.9s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 260, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 27.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 261, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 27.1s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 262, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 27.3s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 263, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 27.4s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 264, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:14] {3190} INFO - at 27.5s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:14] {3010} INFO - iteration 265, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 27.5s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 266, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 27.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 267, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 27.7s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 268, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 27.8s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 269, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 27.9s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 270, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 28.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 271, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 28.1s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 272, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 28.2s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 273, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 28.3s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 274, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:15] {3190} INFO - at 28.4s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:15] {3010} INFO - iteration 275, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 28.5s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 276, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 28.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 277, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 28.7s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 278, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 28.8s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 279, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 28.9s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 280, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 29.0s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 281, current learner rf\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 29.2s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 282, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 29.3s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 283, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 29.4s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 284, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:16] {3190} INFO - at 29.5s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:16] {3010} INFO - iteration 285, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 29.6s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 286, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 29.7s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 287, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 29.8s,\testimator extra_tree's best error=27924.9573,\tbest estimator extra_tree's best error=27924.9573\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 288, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 29.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 289, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 29.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 290, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 30.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 291, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 30.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 292, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 30.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 293, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 30.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 294, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:17] {3190} INFO - at 30.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:17] {3010} INFO - iteration 295, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 30.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 296, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 30.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 297, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 30.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 298, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 31.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 299, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 31.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 300, current learner rf\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 31.4s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 301, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:18] {3190} INFO - at 31.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:18] {3010} INFO - iteration 302, current learner rf\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 31.6s,\testimator rf's best error=55359.0914,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 303, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 31.7s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 304, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 31.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 305, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 31.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 306, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 32.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 307, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 32.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 308, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 32.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 309, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 32.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 310, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:19] {3190} INFO - at 32.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:19] {3010} INFO - iteration 311, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 32.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 312, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 32.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 313, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 32.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 314, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 32.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 315, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 33.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 316, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 33.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 317, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 33.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 318, current learner rf\n", + "[flaml.automl: 08-14 10:22:20] {3190} INFO - at 33.5s,\testimator rf's best error=55284.4927,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:20] {3010} INFO - iteration 319, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 33.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 320, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 33.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 321, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 33.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 322, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 33.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 323, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 34.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 324, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 34.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 325, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 34.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 326, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 34.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 327, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:21] {3190} INFO - at 34.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:21] {3010} INFO - iteration 328, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 34.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 329, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 34.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 330, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 34.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 331, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 34.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 332, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 333, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 334, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 335, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 336, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 337, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:22] {3190} INFO - at 35.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:22] {3010} INFO - iteration 338, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 35.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 339, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 35.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 340, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 36.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 341, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 36.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 342, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 36.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 343, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 36.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 344, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:23] {3190} INFO - at 36.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:23] {3010} INFO - iteration 345, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 36.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 346, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 36.8s,\testimator xgb_limitdepth's best error=36908.4382,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 347, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 36.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 348, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 37.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 349, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 37.1s,\testimator xgboost's best error=43974.7300,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 350, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 37.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 351, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 37.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 352, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:24] {3190} INFO - at 37.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:24] {3010} INFO - iteration 353, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 37.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 354, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 37.7s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 355, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 37.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 356, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 37.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 357, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 38.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 358, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 38.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 359, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 38.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 360, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 38.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 361, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:25] {3190} INFO - at 38.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:25] {3010} INFO - iteration 362, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 38.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 363, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 38.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 364, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 38.7s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 365, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 38.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 366, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 39.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 367, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 39.1s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 368, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 39.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 369, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 39.4s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 370, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:26] {3190} INFO - at 39.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:26] {3010} INFO - iteration 371, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 39.6s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 372, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 39.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 373, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 39.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 374, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 39.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 375, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 40.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 376, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 40.2s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 377, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 40.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 378, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:27] {3190} INFO - at 40.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:27] {3010} INFO - iteration 379, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 40.7s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 380, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 40.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 381, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.0s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 382, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 383, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 384, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 385, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 386, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:28] {3190} INFO - at 41.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:28] {3010} INFO - iteration 387, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 41.6s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 388, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 41.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 389, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 41.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 390, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 41.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 391, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 42.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 392, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 42.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 393, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:29] {3190} INFO - at 42.5s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:29] {3010} INFO - iteration 394, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 42.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 395, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 42.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 396, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 42.8s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 397, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 42.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 398, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 43.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 399, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 43.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 400, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 43.4s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 401, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:30] {3190} INFO - at 43.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:30] {3010} INFO - iteration 402, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 43.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 403, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 43.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 404, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 43.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 405, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 43.9s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 406, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 44.0s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 407, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 44.2s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 408, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 44.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 409, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 44.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 410, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:31] {3190} INFO - at 44.5s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:31] {3010} INFO - iteration 411, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 44.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 412, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 44.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 413, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 45.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 414, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 45.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 415, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 45.3s,\testimator xgboost's best error=43974.7300,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 416, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:32] {3190} INFO - at 45.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:32] {3010} INFO - iteration 417, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 45.6s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 418, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 45.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 419, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 45.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 420, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 421, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.1s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 422, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 423, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.3s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 424, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 425, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:33] {3190} INFO - at 46.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:33] {3010} INFO - iteration 426, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:34] {3190} INFO - at 46.9s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:34] {3010} INFO - iteration 427, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:34] {3190} INFO - at 47.0s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:34] {3010} INFO - iteration 428, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:34] {3190} INFO - at 47.4s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:34] {3010} INFO - iteration 429, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 47.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 430, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 47.7s,\testimator xgboost's best error=43371.5687,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 431, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 47.9s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 432, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 433, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 434, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 435, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 436, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 437, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:35] {3190} INFO - at 48.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:35] {3010} INFO - iteration 438, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 48.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 439, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 48.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 440, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 48.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 441, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 48.9s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 442, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 49.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 443, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 49.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 444, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 49.3s,\testimator xgboost's best error=43371.5687,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 445, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:36] {3190} INFO - at 49.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:36] {3010} INFO - iteration 446, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 49.7s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 447, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 49.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 448, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 50.0s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 449, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 50.1s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 450, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 50.2s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 451, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:37] {3190} INFO - at 50.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:37] {3010} INFO - iteration 452, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 50.5s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 453, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 50.6s,\testimator xgboost's best error=43371.5687,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 454, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 50.7s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 455, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 50.8s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 456, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 50.9s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 457, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 51.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 458, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 51.2s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 459, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 51.3s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 460, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 51.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 461, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:38] {3190} INFO - at 51.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:38] {3010} INFO - iteration 462, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 51.6s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 463, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 51.7s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 464, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 51.7s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 465, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 51.8s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 466, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 51.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 467, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 52.0s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 468, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 52.1s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 469, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 52.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 470, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 52.3s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 471, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:39] {3190} INFO - at 52.5s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:39] {3010} INFO - iteration 472, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 52.5s,\testimator xgboost's best error=39714.3700,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 473, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 52.6s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 474, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 52.7s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 475, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 52.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 476, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 52.9s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 477, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 53.0s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 478, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 53.1s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 479, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:40] {3190} INFO - at 53.3s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:40] {3010} INFO - iteration 480, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 53.6s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 481, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 53.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 482, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 53.9s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 483, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 54.2s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 484, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 54.3s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 485, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:41] {3190} INFO - at 54.4s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:41] {3010} INFO - iteration 486, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 54.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 487, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 54.7s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 488, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 54.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 489, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 54.9s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 490, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 55.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 491, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 55.1s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 492, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 55.2s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 493, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 55.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 494, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:42] {3190} INFO - at 55.4s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:42] {3010} INFO - iteration 495, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 55.6s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 496, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 55.7s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 497, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 55.8s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 498, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 55.9s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 499, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 56.0s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 500, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 56.1s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 501, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 56.2s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 502, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 56.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 503, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:43] {3190} INFO - at 56.5s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:43] {3010} INFO - iteration 504, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 56.6s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 505, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 56.7s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 506, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 56.8s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 507, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 56.9s,\testimator xgboost's best error=36045.9981,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 508, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.0s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 509, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 510, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.2s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 511, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.3s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 512, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.4s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 513, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:44] {3190} INFO - at 57.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:44] {3010} INFO - iteration 514, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 57.6s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 515, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 57.7s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 516, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 57.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 517, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 58.1s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 518, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 58.2s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 519, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 58.4s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 520, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:45] {3190} INFO - at 58.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:45] {3010} INFO - iteration 521, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 58.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 522, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 58.6s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 523, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 58.8s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 524, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 58.9s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 525, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 59.0s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 526, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 59.1s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 527, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 59.2s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 528, current learner xgb_limitdepth\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 59.3s,\testimator xgb_limitdepth's best error=35245.5923,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 529, current learner extra_tree\n", + "[flaml.automl: 08-14 10:22:46] {3190} INFO - at 59.5s,\testimator extra_tree's best error=25599.7995,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:46] {3010} INFO - iteration 530, current learner lgbm\n", + "[flaml.automl: 08-14 10:22:47] {3190} INFO - at 59.8s,\testimator lgbm's best error=37639.5597,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:47] {3010} INFO - iteration 531, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:47] {3190} INFO - at 59.8s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:47] {3010} INFO - iteration 532, current learner xgboost\n", + "[flaml.automl: 08-14 10:22:47] {3190} INFO - at 59.9s,\testimator xgboost's best error=35173.4975,\tbest estimator extra_tree's best error=25599.7995\n", + "[flaml.automl: 08-14 10:22:47] {3454} INFO - retrain extra_tree for 0.0s\n", + "[flaml.automl: 08-14 10:22:47] {3461} INFO - retrained model: ExtraTreesRegressor(max_features=0.662808043114978, max_leaf_nodes=51,\n", + " n_estimators=6, n_jobs=-1)\n", + "[flaml.automl: 08-14 10:22:47] {2739} INFO - fit succeeded\n", + "[flaml.automl: 08-14 10:22:47] {2740} INFO - Time taken to find the best model: 29.838769674301147\n" + ] + } + ], + "source": [ + "automl.fit(X, y, task=\"regression\",metric='rmse',time_budget=60*1*1)# 1min" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best ML leaner: extra_tree\n", + "Best hyperparmeter config: {'n_estimators': 6, 'max_features': 0.662808043114978, 'max_leaves': 51}\n", + "Best rmse on validation data: 2.56e+04\n", + "Training duration of best run: 0.02701 s\n" + ] + } + ], + "source": [ + "print('Best ML leaner:', automl.best_estimator)\n", + "print('Best hyperparmeter config:', automl.best_config)\n", + "print('Best rmse on validation data: {0:.4g}'.format(automl.best_loss))\n", + "print('Training duration of best run: {0:.4g} s'.format(automl.best_config_train_time))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

5 | 获取模型精度

" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE: 522.519\n" + ] + }, + { + "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", + "
Artist IDDateCatalogueDepartmentClassificationHeight (cm)Width (cm)Prices
011975.000050.050.04000.0
111975.000050.050.04000.0
211975.000050.050.04000.0
311975.000045.045.04000.0
411975.000045.045.04000.0
\n", + "
" + ], + "text/plain": [ + " Artist ID Date Catalogue Department Classification Height (cm) \\\n", + "0 1 1975.0 0 0 0 50.0 \n", + "1 1 1975.0 0 0 0 50.0 \n", + "2 1 1975.0 0 0 0 50.0 \n", + "3 1 1975.0 0 0 0 45.0 \n", + "4 1 1975.0 0 0 0 45.0 \n", + "\n", + " Width (cm) Prices \n", + "0 50.0 4000.0 \n", + "1 50.0 4000.0 \n", + "2 50.0 4000.0 \n", + "3 45.0 4000.0 \n", + "4 45.0 4000.0 " + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import mean_absolute_error\n", + "import pickle\n", + "with open(\"model_data/automl_v2.pkl\", \"wb\") as f:\n", + " pickle.dump(automl, f, pickle.HIGHEST_PROTOCOL)\n", + "\n", + "# 加载模型并预测\n", + "with open(\"model_data/automl_v2.pkl\", \"rb\") as f:\n", + " automl = pickle.load(f)\n", + "\n", + "pred = automl.predict(X)\n", + "mae = mean_absolute_error(y, pred)\n", + "print(\"MAE: %.3f\" % mae)\n", + "train_data[\"Prices\"] = pred\n", + "train_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(train_data[\"Prices\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "train_data.to_csv(\"preds.csv\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.3 ('base')", + "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.8.3" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "b09ec625f77bf4fd762565a912b97636504ad6ec901eb2d0f4cf5a7de23e1ee5" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}