{ "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 }