medium1-cuml.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://docs.rapids.ai/api/cuml/stable/api.html#random-forest\n",
    "# https://docs.rapids.ai/api/cuml/stable/api.html#support-vector-machines\n",
    "# https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.204 | INFO     | __main__:<module>:20 - psutil.__version__: 5.9.4\n",
      "2023-01-07 18:08:07.205 | INFO     | __main__:<module>:21 - cuml.__version__: 22.12.00\n",
      "2023-01-07 18:08:07.206 | INFO     | __main__:<module>:22 - cudf.__version__: 22.12.01\n",
      "2023-01-07 18:08:07.206 | INFO     | __main__:<module>:23 - cupy.__version__: 11.4.0\n",
      "2023-01-07 18:08:07.207 | INFO     | __main__:<module>:24 - sklearn.__version__: 1.2.0\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import datetime\n",
    "import psutil\n",
    "from cuml.model_selection import train_test_split as tts_cuml\n",
    "from sklearn.metrics import accuracy_score as acc_sk\n",
    "from cuml.metrics import accuracy_score as acc_cuml\n",
    "import cuml\n",
    "import cupy\n",
    "import sklearn\n",
    "from cupy import asnumpy\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import cudf\n",
    "from loguru import logger\n",
    "import platform\n",
    "\n",
    "logger.add(\"medium1-cuml.log\")\n",
    "logger.info(f\"psutil.__version__: {psutil.__version__}\")\n",
    "logger.info(f\"cuml.__version__: {cuml.__version__}\")\n",
    "logger.info(f\"cudf.__version__: {cudf.__version__}\")\n",
    "logger.info(f\"cupy.__version__: {cupy.__version__}\")\n",
    "logger.info(f\"sklearn.__version__: {sklearn.__version__}\")\n",
    "\n",
    "from pynvml import *\n",
    "nvmlInit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.247 | INFO     | __main__:<module>:1 - Driver Version: b'470.161.03'\n"
     ]
    }
   ],
   "source": [
    "logger.info(f\"Driver Version: {nvmlSystemGetDriverVersion()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.282 | INFO     | __main__:<module>:4 - Device 0: b'NVIDIA GeForce RTX 2060'\n"
     ]
    }
   ],
   "source": [
    "deviceCount = nvmlDeviceGetCount()\n",
    "for i in range(deviceCount):\n",
    "    handle = nvmlDeviceGetHandleByIndex(i)\n",
    "    logger.info(f\"Device {i}: {nvmlDeviceGetName(handle)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !nvidia-smi # CUDA Version: 11.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.333 | INFO     | __main__:<module>:1 - Python version: 3.9.15\n"
     ]
    }
   ],
   "source": [
    "logger.info(f\"Python version: {platform.python_version()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.357 | INFO     | __main__:<module>:2 - Sistema operacional:\n",
      " NAME=\"Ubuntu\"\n",
      "VERSION=\"18.04.6 LTS (Bionic Beaver)\"\n",
      "ID=ubuntu\n",
      "ID_LIKE=debian\n",
      "PRETTY_NAME=\"Ubuntu 18.04.6 LTS\"\n",
      "VERSION_ID=\"18.04\"\n",
      "HOME_URL=\"https://www.ubuntu.com/\"\n",
      "SUPPORT_URL=\"https://help.ubuntu.com/\"\n",
      "BUG_REPORT_URL=\"https://bugs.launchpad.net/ubuntu/\"\n",
      "PRIVACY_POLICY_URL=\"https://www.ubuntu.com/legal/terms-and-policies/privacy-policy\"\n",
      "VERSION_CODENAME=bionic\n",
      "UBUNTU_CODENAME=bionic\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"/etc/os-release\", \"r\")\n",
    "logger.info(f\"Sistema operacional:\\n {f.read()}\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:07.402 | INFO     | __main__:<module>:3 - Memória total: 16 GB\n"
     ]
    }
   ],
   "source": [
    "meminfo = dict((i.split()[0].rstrip(':'),int(i.split()[1])) for i in open('/proc/meminfo').readlines())\n",
    "mem_kib = meminfo['MemTotal']\n",
    "logger.info(f\"Memória total: {str(mem_kib)[:2]} GB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RANGE                                 SIZE  STATE REMOVABLE  BLOCK\n",
      "0x0000000000000000-0x000000007fffffff   2G online       yes   0-15\n",
      "0x0000000100000000-0x000000047fffffff  14G online       yes 32-143\n",
      "\n",
      "Memory block size:       128M\n",
      "Total online memory:      16G\n",
      "Total offline memory:      0B\n"
     ]
    }
   ],
   "source": [
    "!lsmem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !lscpu # Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:08.140 | INFO     | __main__:<module>:3 - Total de núcleos do processador: 12\n"
     ]
    }
   ],
   "source": [
    "# https://psutil.readthedocs.io/en/latest/\n",
    "import psutil\n",
    "logger.info(f\"Total de núcleos do processador: {psutil.cpu_count(logical=True)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_init(inductor):\n",
    "    logger.info(f\"INDUTOR: {inductor}\")\n",
    "    time_start = time.time()\n",
    "    datetime_start = datetime.datetime.now()\n",
    "    return datetime_start, time_start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_print(datetime_start, time_start):\n",
    "    time_end = time.time()\n",
    "    datetime_end = datetime.datetime.now()\n",
    "    elapsed_datetime = (datetime_end - datetime_start)\n",
    "    elapsed_time = (time_end - time_start)\n",
    "    logger.warning(f\"Tempo de execução (datetime): {str(elapsed_datetime)} segundos\")\n",
    "    logger.warning(f\"Tempo de execução (time): {str(elapsed_time)} segundos\")\n",
    "    return elapsed_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_performance(rapids, sklearn):\n",
    "    exp1 = 'SKLEARN' if sklearn < rapids else 'CUML'\n",
    "    exp2 = 'SKLEARN' if sklearn > rapids else 'CUML'\n",
    "    exp3 = (sklearn/rapids if sklearn > rapids else rapids/sklearn)\n",
    "    exp4 = exp3 >= 2\n",
    "    exp5 = ('vezes' if exp4 else 'vez')\n",
    "    logger.success(f\"RESULTADO: {exp1} foi mais rápido que o {exp2} {exp3} {exp5}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def metrics_cuml_sklearn(framework, inductor, y_test_cuml, predictions_cuml, y_test_sk, predictions_sk):\n",
    "    cu_score = acc_cuml(y_test_cuml, predictions_cuml)\n",
    "    sk_score = acc_sk(y_test_sk, predictions_sk)\n",
    "    logger.debug(f\"{framework} - cuml accuracy: {cu_score}\")\n",
    "    logger.debug(f\"{framework} - sklearn accuracy: {sk_score}\")\n",
    "    logger.trace(f\"PARAMETROS: {str(inductor.get_params())}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_prepare_dataset(filename):\n",
    "    '''\n",
    "    Carregando os dados usando o CUDF.\n",
    "    '''\n",
    "    logger.info(f\"filename: {filename}\")\n",
    "    cu_df = cudf.read_csv(filename)\n",
    "    logger.info(f\"cu_df.shape: {cu_df.shape}\")\n",
    "    y = cu_df['class']\n",
    "    X = cu_df.drop(columns=['class'])\n",
    "    logger.info(f\"X.shape: {X.shape}\")\n",
    "    logger.info(f\"y.shape: {y.shape}\")\n",
    "    return tts_cuml( X, y, random_state = 3, test_size=0.3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Dataset 1</h1>\n",
    "<h3>250.000 amostras</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:08.382 | INFO     | __main__:load_prepare_dataset:5 - filename: medium1_dt1.csv\n",
      "2023-01-07 18:08:11.964 | INFO     | __main__:load_prepare_dataset:7 - cu_df.shape: (250000, 102)\n",
      "2023-01-07 18:08:11.984 | INFO     | __main__:load_prepare_dataset:10 - X.shape: (250000, 101)\n",
      "2023-01-07 18:08:11.985 | INFO     | __main__:load_prepare_dataset:11 - y.shape: (250000,)\n"
     ]
    }
   ],
   "source": [
    "filename = \"medium1_dt1.csv\"\n",
    "X_train, X_test, y_train, y_test = load_prepare_dataset(filename)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Random Forest</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:12.120 | INFO     | __main__:<module>:2 - params_rf: {'max_features': 'sqrt', 'max_depth': 16, 'random_state': 7, 'verbose': 0}\n"
     ]
    }
   ],
   "source": [
    "params_rf = {'max_features':'sqrt', 'max_depth':16, 'random_state':7, 'verbose':0}\n",
    "logger.info(f\"params_rf: {params_rf}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:12.139 | INFO     | __main__:time_init:2 - INDUTOR: <class 'cuml.ensemble.randomforestclassifier.RandomForestClassifier'>\n",
      "/home/rafaelfazevedo/anaconda3/envs/kaggle/lib/python3.9/site-packages/cuml/internals/api_decorators.py:794: UserWarning: For reproducible results in Random Forest Classifier or for almost reproducible results in Random Forest Regressor, n_streams=1 is recommended. If n_streams is > 1, results may vary due to stream/thread timing differences, even when random_state is set\n",
      "  return func(**kwargs)\n",
      "/home/rafaelfazevedo/anaconda3/envs/kaggle/lib/python3.9/site-packages/cuml/internals/api_decorators.py:567: UserWarning: To use pickling first train using float32 data to fit the estimator\n",
      "  ret_val = func(*args, **kwargs)\n",
      "2023-01-07 18:08:15.768 | DEBUG    | __main__:metrics_cuml_sklearn:4 - CUML - cuml accuracy: 0.7810800075531006\n",
      "2023-01-07 18:08:15.768 | DEBUG    | __main__:metrics_cuml_sklearn:5 - CUML - sklearn accuracy: 0.78108\n",
      "2023-01-07 18:08:15.769 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:00:03.628787 segundos\n",
      "2023-01-07 18:08:15.770 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 3.6287872791290283 segundos\n"
     ]
    }
   ],
   "source": [
    "from cuml.ensemble import RandomForestClassifier as cuRFC\n",
    "datetime_start, time_start = time_init(cuRFC)\n",
    "cuml_model = cuRFC(**params_rf)\n",
    "cuml_model.fit(X_train,y_train)\n",
    "predictions = cuml_model.predict (X_test)\n",
    "metrics_cuml_sklearn('CUML', cuml_model, y_test, predictions, asnumpy(y_test), asnumpy(predictions))\n",
    "rap = time_print(datetime_start, time_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:15.788 | INFO     | __main__:time_init:2 - INDUTOR: <class 'sklearn.ensemble._forest.RandomForestClassifier'>\n",
      "2023-01-07 18:08:49.246 | DEBUG    | __main__:metrics_cuml_sklearn:4 - SKLEARN - cuml accuracy: 0.8966266512870789\n",
      "2023-01-07 18:08:49.247 | DEBUG    | __main__:metrics_cuml_sklearn:5 - SKLEARN - sklearn accuracy: 0.8966266666666667\n",
      "2023-01-07 18:08:49.262 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:00:33.472368 segundos\n",
      "2023-01-07 18:08:49.262 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 33.47236895561218 segundos\n",
      "2023-01-07 18:08:49.263 | SUCCESS  | __main__:print_performance:7 - RESULTADO: CUML foi mais rápido que o SKLEARN 9.22411990036686 vezes\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier as skRF_n_jobs\n",
    "datetime_start, time_start = time_init(skRF_n_jobs)\n",
    "clf = skRF_n_jobs(**params_rf, n_jobs=11)\n",
    "clf.fit(X_train.to_numpy(), y_train.to_numpy())\n",
    "predictions = clf.predict (X_test.to_numpy())\n",
    "metrics_cuml_sklearn('SKLEARN', clf, y_test.to_numpy(), predictions, y_test.to_numpy(), predictions)\n",
    "skl = time_print(datetime_start, time_start)\n",
    "print_performance(rap, skl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:08:49.284 | INFO     | __main__:time_init:2 - INDUTOR: <class 'sklearn.ensemble._forest.RandomForestClassifier'>\n",
      "2023-01-07 18:11:49.551 | DEBUG    | __main__:metrics_cuml_sklearn:4 - SKLEARN - cuml accuracy: 0.8966266512870789\n",
      "2023-01-07 18:11:49.552 | DEBUG    | __main__:metrics_cuml_sklearn:5 - SKLEARN - sklearn accuracy: 0.8966266666666667\n",
      "2023-01-07 18:11:49.553 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:03:00.267529 segundos\n",
      "2023-01-07 18:11:49.553 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 180.2675290107727 segundos\n",
      "2023-01-07 18:11:49.554 | SUCCESS  | __main__:print_performance:7 - RESULTADO: CUML foi mais rápido que o SKLEARN 49.677072571208974 vezes\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier as skRF_single_job\n",
    "datetime_start, time_start = time_init(skRF_single_job)\n",
    "clf = skRF_single_job(**params_rf)\n",
    "clf.fit(X_train.to_numpy(), y_train.to_numpy())\n",
    "predictions = clf.predict (X_test.to_numpy())\n",
    "metrics_cuml_sklearn('SKLEARN', clf, y_test.to_numpy(), predictions, y_test.to_numpy(), predictions)\n",
    "skl = time_print(datetime_start, time_start)\n",
    "print_performance(rap, skl)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>LinearSVC</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:11:49.578 | INFO     | __main__:<module>:2 - params_linear_svc: {'loss': 'squared_hinge', 'penalty': 'l2', 'C': 1, 'verbose': 0}\n"
     ]
    }
   ],
   "source": [
    "params_linear_svc = {'loss':'squared_hinge', 'penalty':'l2', 'C':1, 'verbose':0}\n",
    "logger.info(f\"params_linear_svc: {params_linear_svc}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:11:49.600 | INFO     | __main__:time_init:2 - INDUTOR: <class 'cuml.svm.linear_svc.LinearSVC'>\n",
      "2023-01-07 18:11:50.337 | DEBUG    | __main__:metrics_cuml_sklearn:4 - CUML - cuml accuracy: 0.873520016670227\n",
      "2023-01-07 18:11:50.337 | DEBUG    | __main__:metrics_cuml_sklearn:5 - CUML - sklearn accuracy: 0.87352\n",
      "2023-01-07 18:11:50.338 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:00:00.737249 segundos\n",
      "2023-01-07 18:11:50.339 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 0.7372500896453857 segundos\n"
     ]
    }
   ],
   "source": [
    "from cuml.svm import LinearSVC as cuLinearSVC\n",
    "datetime_start, time_start = time_init(cuLinearSVC)\n",
    "cu_linear_SVC = cuLinearSVC(**params_linear_svc)\n",
    "cu_linear_SVC.fit(X_train, y_train)\n",
    "predictions = cu_linear_SVC.predict (X_test)\n",
    "metrics_cuml_sklearn('CUML', cu_linear_SVC , y_test, predictions, y_test.to_numpy(), predictions.to_numpy())\n",
    "rap = time_print(datetime_start, time_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:11:50.357 | INFO     | __main__:time_init:2 - INDUTOR: <class 'sklearn.svm._classes.LinearSVC'>\n",
      "/home/rafaelfazevedo/anaconda3/envs/kaggle/lib/python3.9/site-packages/sklearn/svm/_base.py:1244: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  warnings.warn(\n",
      "2023-01-07 18:15:56.115 | DEBUG    | __main__:metrics_cuml_sklearn:4 - SKLEARN - cuml accuracy: 0.8750799894332886\n",
      "2023-01-07 18:15:56.117 | DEBUG    | __main__:metrics_cuml_sklearn:5 - SKLEARN - sklearn accuracy: 0.87508\n",
      "2023-01-07 18:15:56.118 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:04:05.759948 segundos\n",
      "2023-01-07 18:15:56.119 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 245.75994777679443 segundos\n",
      "2023-01-07 18:15:56.120 | SUCCESS  | __main__:print_performance:7 - RESULTADO: CUML foi mais rápido que o SKLEARN 333.3467858851044 vezes\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import LinearSVC as skLinearSVC\n",
    "datetime_start, time_start = time_init(skLinearSVC)\n",
    "sk_linear_SVC = skLinearSVC(**params_linear_svc)\n",
    "sk_linear_SVC.fit(X_train.to_numpy(), y_train.to_numpy())\n",
    "predictions = sk_linear_SVC.predict (X_test.to_numpy())\n",
    "metrics_cuml_sklearn('SKLEARN', sk_linear_SVC, y_test.to_numpy(), predictions, y_test.to_numpy(), predictions)\n",
    "skl = time_print(datetime_start, time_start)\n",
    "print_performance(rap, skl)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Dataset 2</h1>\n",
    "<h3>100.000 amostras</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:15:56.205 | INFO     | __main__:load_prepare_dataset:5 - filename: medium1_dt_100k.csv\n",
      "2023-01-07 18:15:56.343 | INFO     | __main__:load_prepare_dataset:7 - cu_df.shape: (100000, 102)\n",
      "2023-01-07 18:15:56.356 | INFO     | __main__:load_prepare_dataset:10 - X.shape: (100000, 101)\n",
      "2023-01-07 18:15:56.357 | INFO     | __main__:load_prepare_dataset:11 - y.shape: (100000,)\n"
     ]
    }
   ],
   "source": [
    "filename = \"medium1_dt_100k.csv\"\n",
    "X_train, X_test, y_train, y_test = load_prepare_dataset(filename)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>SVC</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:15:56.399 | INFO     | __main__:<module>:2 - params_svc: {'kernel': 'poly', 'degree': 2, 'gamma': 'scale', 'C': 1, 'random_state': 7, 'verbose': 0}\n"
     ]
    }
   ],
   "source": [
    "params_svc = {'kernel':'poly', 'degree':2, 'gamma':'scale', 'C':1, 'random_state':7, 'verbose':0}\n",
    "logger.info(f\"params_svc: {params_svc}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:15:56.423 | INFO     | __main__:time_init:2 - INDUTOR: <class 'cuml.svm.svc.SVC'>\n",
      "2023-01-07 18:16:54.121 | DEBUG    | __main__:metrics_cuml_sklearn:4 - CUML - cuml accuracy: 0.6628999710083008\n",
      "2023-01-07 18:16:54.122 | DEBUG    | __main__:metrics_cuml_sklearn:5 - CUML - sklearn accuracy: 0.6629\n",
      "2023-01-07 18:16:54.122 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:00:57.697369 segundos\n",
      "2023-01-07 18:16:54.123 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 57.69736957550049 segundos\n"
     ]
    }
   ],
   "source": [
    "from cuml.svm import SVC as cumlSVC\n",
    "datetime_start, time_start = time_init(cumlSVC)\n",
    "cuml_model = cumlSVC(**params_svc)\n",
    "cuml_model.fit(X_train, y_train)\n",
    "predictions = cuml_model.predict (X_test)\n",
    "metrics_cuml_sklearn('CUML', cuml_model, y_test, predictions, asnumpy(y_test), asnumpy(predictions))\n",
    "rap = time_print(datetime_start, time_start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-01-07 18:16:54.145 | INFO     | __main__:time_init:2 - INDUTOR: <class 'sklearn.svm._classes.SVC'>\n",
      "2023-01-07 18:34:01.104 | DEBUG    | __main__:metrics_cuml_sklearn:4 - SKLEARN - cuml accuracy: 0.6615666747093201\n",
      "2023-01-07 18:34:01.104 | DEBUG    | __main__:metrics_cuml_sklearn:5 - SKLEARN - sklearn accuracy: 0.6615666666666666\n",
      "2023-01-07 18:34:01.105 | WARNING  | __main__:time_print:6 - Tempo de execução (datetime): 0:17:06.957642 segundos\n",
      "2023-01-07 18:34:01.105 | WARNING  | __main__:time_print:7 - Tempo de execução (time): 1026.957641839981 segundos\n",
      "2023-01-07 18:34:01.107 | SUCCESS  | __main__:print_performance:7 - RESULTADO: CUML foi mais rápido que o SKLEARN 17.799037449985395 vezes\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC as skSVC\n",
    "datetime_start, time_start = time_init(skSVC)\n",
    "clf = skSVC(**params_svc)\n",
    "clf.fit(X_train.to_numpy(), y_train.to_numpy())\n",
    "predictions = clf.predict (X_test.to_numpy())\n",
    "metrics_cuml_sklearn('SKLEARN', clf, y_test.to_numpy(), predictions, y_test.to_numpy(), predictions)\n",
    "skl = time_print(datetime_start, time_start)\n",
    "print_performance(rap, skl)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "kaggle",
   "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.9.15 | packaged by conda-forge | (main, Nov 22 2022, 08:45:29) \n[GCC 10.4.0]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "69a250b4ffd41b2e06401b410be13412a195e5fa31b1fe51fb767b931a7819be"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}