{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Example: XGBoost.to_json\n", "\n", "Starting from VerticaPy 0.7.1, you can export any native Vertica XGBoost model to the Python XGBoost JSON file format. This page demonstrates the exporting process and the nuances involved." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Connect to Vertica\n", "\n", "For a demonstration on how to create a new connection to Vertica, see connection. In this example, we will use an existing connection named 'VerticaDSN'." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "import verticapy as vp\n", "vp.connect(\"VerticaDSN\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create a Schema (Optional)\n", "\n", "Schemas allow you to organize database objects in a collection, similar to a namespace. If you create a database object without specifying a schema, Vertica uses the 'public' schema. For example, to specify the 'example_table' in 'example_schema', you would use: 'example_schema.example_table'.\n", "\n", "To keep things organized, this example creates the 'xgb_to_json' schema and drops it (and its associated tables, views, etc.) at the end:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vp.drop(\"xgb_to_json\", method = \"schema\")\n", "vp.create_schema(\"xgb_to_json\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Data\n", "\n", "VerticaPy lets you load many well-known datasets like Iris, Titanic, Amazon, etc.\n", "\n", "This example loads the Titanic dataset with the load_titanic function into a table called 'titanic' in the 'xgb_to_json' schema:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from verticapy.datasets import load_titanic\n", "vdf = load_titanic(name = \"titanic\",\n", " schema = \"xgb_to_json\",)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can also load your own data. To ingest data from a CSV file, use the read_csv() function.\n", "\n", "The read_csv() function uses parses the dataset and uses [flex tables](https://www.vertica.com/docs/latest/HTML/Content/Authoring/FlexTables/UnderstandingFlexTables.htm) to identify data types. \n", "\n", "If read_csv() runs for too long, you can use the 'parse_nrows' parameters to limit the number of lines read_csv() parses before guessing the data types at the possible expense of data type identification accuracy.\n", "\n", "For example, to load the 'iris.csv' file with the read_csv() function:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The table \"xgb_to_json\".\"iris\" has been successfully created.\n" ] } ], "source": [ "vdf = vp.read_csv(\"data/iris.csv\",\n", " table_name = \"iris\",\n", " schema = \"xgb_to_json\",)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create a vDataFrame\n", "\n", "vDataFrames allow you to prepare and explore your data without modifying its representation in your Vertica database. Any changes you make are applied to the vDataFrame as modifications to the SQL query for the table underneath. \n", "\n", "To create a vDataFrame out of a table in your Vertica database, specify its schema and table name with the standard SQL syntax. For example, to create a vDataFrame out of the 'titanic' table in the 'xgb_to_json' schema:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "vdf = vp.vDataFrame(\"xgb_to_json.titanic\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create an XGB model\n", "\n", "Create a XGBoostClassifier XGBoostClassifier model.\n", "\n", "Unlike a vDataFrame object, which simply queries the table it was created with, the VerticaPy XGBoostClassifier object creates and then references a model in Vertica, so it must be stored in a schema like any other database object.\n", "\n", "This example creates the 'my_model' XGBoostClassifier model in the 'xgb_to_json' schema:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "from verticapy.learn.ensemble import XGBoostClassifier\n", "model = XGBoostClassifier(\"xgb_to_json.my_model\",\n", " max_ntree = 4,\n", " max_depth = 3,)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Prepare the Data\n", "\n", "While Vertica XGBoost supports columns of type VARCHAR, Python XGBoost does not, so you must encode the categorical columns you want to use. You must also drop or impute missing values.\n", "\n", "This example drops 'age,' 'fare,' 'sex,' 'embarked,' and 'survived' columns from the vDataFrame and then encodes the 'sex' and 'embarked' columns. These changes are applied to the vDataFrame's query and does not affect the main \"xgb_to_json.titanic' table stored in Vertica:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Nothing was filtered.\n" ] }, { "data": { "text/html": [ "
123
age
Numeric(6,3)
123
fare
Numeric(10,5)
123
sex
Int
123
embarked
Int
123
survived
Int
12.0151.55020
230.0151.55120
325.0151.55020
439.00.0120
571.049.5042100
647.0227.525100
724.0247.5208100
836.075.2417100
925.026.0100
1045.035.5120
1142.026.55120
1241.030.5120
1348.050.4958100
1445.026.55120
1533.05.0120
1628.047.1120
1717.047.1120
1849.026.0120
1936.078.85120
2046.061.175120
2127.0136.7792100
2247.025.5875120
2337.083.1583100
2470.071.0120
2539.071.2833100
2631.052.0120
2750.0106.425100
2839.029.7100
2936.031.6792000
3030.027.75100
3119.0263.0120
3264.0263.0120
3337.053.1120
3447.038.5120
3524.079.2100
3671.034.6542100
3738.0153.4625120
3846.079.2100
3945.083.475120
4040.00.0120
4155.093.5120
4242.042.5120
4355.050.0120
4442.052.0120
4550.028.7125000
4646.026.0120
4750.026.0120
4832.5211.5100
4958.029.7100
5041.051.8625120
5129.030.0120
5230.045.5120
5330.026.0120
5419.053.1120
5546.075.2417100
5654.051.8625120
5728.082.1708100
5865.026.55120
5944.090.0110
6055.030.5120
6147.042.4120
6237.029.7100
6358.0113.275100
6464.026.0120
6565.061.9792100
6628.527.7208100
6745.528.5120
6823.093.5120
6929.066.6120
7018.0108.9100
7147.052.0120
7238.00.0120
7322.0135.6333100
7431.050.4958120
7536.040.125100
7655.059.4100
7733.026.55120
7861.0262.375100
7950.055.9120
8056.026.55120
8156.030.6958100
8224.060.0120
8357.0146.5208100
8462.026.55120
8567.0221.7792120
8663.0221.7792020
8761.032.3208120
8852.079.65120
8949.0110.8833100
9040.027.7208100
9161.033.5120
9247.034.0208120
9364.075.25100
9460.026.55120
9554.077.2875120
9621.077.2875120
9757.0164.8667120
9850.0211.5100
9927.0211.5100
10051.061.3792100
Rows: 1-100 of 994 | Columns: 5
" ], "text/plain": [ " age fare sex embarked survived \n", "1 2.0 151.55 0 2 0 \n", "2 30.0 151.55 1 2 0 \n", "3 25.0 151.55 0 2 0 \n", "4 39.0 0.0 1 2 0 \n", "5 71.0 49.5042 1 0 0 \n", "6 47.0 227.525 1 0 0 \n", "7 24.0 247.5208 1 0 0 \n", "8 36.0 75.2417 1 0 0 \n", "9 25.0 26.0 1 0 0 \n", "10 45.0 35.5 1 2 0 \n", "11 42.0 26.55 1 2 0 \n", "12 41.0 30.5 1 2 0 \n", "13 48.0 50.4958 1 0 0 \n", "14 45.0 26.55 1 2 0 \n", "15 33.0 5.0 1 2 0 \n", "16 28.0 47.1 1 2 0 \n", "17 17.0 47.1 1 2 0 \n", "18 49.0 26.0 1 2 0 \n", "19 36.0 78.85 1 2 0 \n", "20 46.0 61.175 1 2 0 \n", "21 27.0 136.7792 1 0 0 \n", "22 47.0 25.5875 1 2 0 \n", "23 37.0 83.1583 1 0 0 \n", "24 70.0 71.0 1 2 0 \n", "25 39.0 71.2833 1 0 0 \n", "26 31.0 52.0 1 2 0 \n", "27 50.0 106.425 1 0 0 \n", "28 39.0 29.7 1 0 0 \n", "29 36.0 31.6792 0 0 0 \n", "30 30.0 27.75 1 0 0 \n", "31 19.0 263.0 1 2 0 \n", "32 64.0 263.0 1 2 0 \n", "33 37.0 53.1 1 2 0 \n", "34 47.0 38.5 1 2 0 \n", "35 24.0 79.2 1 0 0 \n", "36 71.0 34.6542 1 0 0 \n", "37 38.0 153.4625 1 2 0 \n", "38 46.0 79.2 1 0 0 \n", "39 45.0 83.475 1 2 0 \n", "40 40.0 0.0 1 2 0 \n", "41 55.0 93.5 1 2 0 \n", "42 42.0 42.5 1 2 0 \n", "43 55.0 50.0 1 2 0 \n", "44 42.0 52.0 1 2 0 \n", "45 50.0 28.7125 0 0 0 \n", "46 46.0 26.0 1 2 0 \n", "47 50.0 26.0 1 2 0 \n", "48 32.5 211.5 1 0 0 \n", "49 58.0 29.7 1 0 0 \n", "50 41.0 51.8625 1 2 0 \n", "51 29.0 30.0 1 2 0 \n", "52 30.0 45.5 1 2 0 \n", "53 30.0 26.0 1 2 0 \n", "54 19.0 53.1 1 2 0 \n", "55 46.0 75.2417 1 0 0 \n", "56 54.0 51.8625 1 2 0 \n", "57 28.0 82.1708 1 0 0 \n", "58 65.0 26.55 1 2 0 \n", "59 44.0 90.0 1 1 0 \n", "60 55.0 30.5 1 2 0 \n", "61 47.0 42.4 1 2 0 \n", "62 37.0 29.7 1 0 0 \n", "63 58.0 113.275 1 0 0 \n", "64 64.0 26.0 1 2 0 \n", "65 65.0 61.9792 1 0 0 \n", "66 28.5 27.7208 1 0 0 \n", "67 45.5 28.5 1 2 0 \n", "68 23.0 93.5 1 2 0 \n", "69 29.0 66.6 1 2 0 \n", "70 18.0 108.9 1 0 0 \n", "71 47.0 52.0 1 2 0 \n", "72 38.0 0.0 1 2 0 \n", "73 22.0 135.6333 1 0 0 \n", "74 31.0 50.4958 1 2 0 \n", "75 36.0 40.125 1 0 0 \n", "76 55.0 59.4 1 0 0 \n", "77 33.0 26.55 1 2 0 \n", "78 61.0 262.375 1 0 0 \n", "79 50.0 55.9 1 2 0 \n", "80 56.0 26.55 1 2 0 \n", "81 56.0 30.6958 1 0 0 \n", "82 24.0 60.0 1 2 0 \n", "83 57.0 146.5208 1 0 0 \n", "84 62.0 26.55 1 2 0 \n", "85 67.0 221.7792 1 2 0 \n", "86 63.0 221.7792 0 2 0 \n", "87 61.0 32.3208 1 2 0 \n", "88 52.0 79.65 1 2 0 \n", "89 49.0 110.8833 1 0 0 \n", "90 40.0 27.7208 1 0 0 \n", "91 61.0 33.5 1 2 0 \n", "92 47.0 34.0208 1 2 0 \n", "93 64.0 75.25 1 0 0 \n", "94 60.0 26.55 1 2 0 \n", "95 54.0 77.2875 1 2 0 \n", "96 21.0 77.2875 1 2 0 \n", "97 57.0 164.8667 1 2 0 \n", "98 50.0 211.5 1 0 0 \n", "99 27.0 211.5 1 0 0 \n", "100 51.0 61.3792 1 0 0 \n", "... ... ... ... ... ... \n", "Rows: 1-100 of 994 | Columns: 5" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vdf = vdf[[\"age\", \"fare\", \"sex\", \"embarked\", \"survived\"]]\n", "vdf.dropna()\n", "vdf[\"sex\"].label_encode()\n", "vdf[\"embarked\"].label_encode()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Train the Model\n", "\n", "Define the predictor and the response columns:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "relation = \"xgb_to_json.titanic\"\n", "X = [\"age\", \"fare\", \"sex\", \"embarked\"]\n", "y = \"survived\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Train the model with fit():" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\n", "\n", "===========\n", "call_string\n", "===========\n", "xgb_classifier('xgb_to_json.my_model', 'xgb_to_json.titanic', '\"survived\"', '\"age\", \"fare\", \"sex\", \"embarked\"' USING PARAMETERS exclude_columns='', max_ntree=4, max_depth=3, learning_rate=0.1, min_split_loss=0, weight_reg=0, nbins=32, objective=crossentropy, sampling_size=1, col_sample_by_tree=1, col_sample_by_node=1)\n", "\n", "=======\n", "details\n", "=======\n", "predictor| type \n", "---------+----------------\n", " age |float or numeric\n", " fare |float or numeric\n", " sex |char or varchar \n", "embarked |char or varchar \n", "\n", "\n", "===============\n", "Additional Info\n", "===============\n", " Name |Value\n", "------------------+-----\n", " tree_count | 4 \n", "rejected_row_count| 240 \n", "accepted_row_count| 994 " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.fit(relation, X, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluate the Model\n", "\n", "Evaluate the model with .report():" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
value
auc0.807342412203361
prc_auc0.8090882088048466
accuracy0.789738430583501
log_loss0.253652070598684
precision0.7261306532663316
recall0.7429305912596401
f1_score0.7794904143408312
mcc0.5605510039144916
informedness0.5627653020034418
markedness0.5583454183670029
csi0.5803212851405622
cutoff0.4804
Rows: 1-12 | Columns: 2
" ], "text/plain": [ " value \n", "auc 0.807342412203361 \n", "prc_auc 0.8090882088048466 \n", "accuracy 0.789738430583501 \n", "log_loss 0.253652070598684 \n", "precision 0.7261306532663316 \n", "recall 0.7429305912596401 \n", "f1_score 0.7794904143408312 \n", "mcc 0.5605510039144916 \n", "informedness 0.5627653020034418 \n", "markedness 0.5583454183670029 \n", "csi 0.5803212851405622 \n", "cutoff 0.4804 \n", "Rows: 1-12 | Columns: 2" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.report()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use to_json() to export the model to a JSON file. If you omit a filename, VerticaPy prints the model:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'{\"learner\": {\"attributes\": {\"scikit_learn\": \"{\\\\\"use_label_encoder\\\\\": true, \\\\\"n_estimators\\\\\": 4, \\\\\"objective\\\\\": \\\\\"binary:logistic\\\\\", \\\\\"max_depth\\\\\": 3, \\\\\"learning_rate\\\\\": 0.1, \\\\\"verbosity\\\\\": null, \\\\\"booster\\\\\": null, \\\\\"tree_method\\\\\": null, \\\\\"gamma\\\\\": null, \\\\\"min_child_weight\\\\\": null, \\\\\"max_delta_step\\\\\": null, \\\\\"subsample\\\\\": null, \\\\\"colsample_bytree\\\\\": 1.0, \\\\\"colsample_bylevel\\\\\": null, \\\\\"colsample_bynode\\\\\": 1.0, \\\\\"reg_alpha\\\\\": null, \\\\\"reg_lambda\\\\\": null, \\\\\"scale_pos_weight\\\\\": null, \\\\\"base_score\\\\\": null, \\\\\"missing\\\\\": NaN, \\\\\"num_parallel_tree\\\\\": null, \\\\\"kwargs\\\\\": {}, \\\\\"random_state\\\\\": null, \\\\\"n_jobs\\\\\": null, \\\\\"monotone_constraints\\\\\": null, \\\\\"interaction_constraints\\\\\": null, \\\\\"importance_type\\\\\": \\\\\"gain\\\\\", \\\\\"gpu_id\\\\\": null, \\\\\"validate_parameters\\\\\": null, \\\\\"classes_\\\\\": [0, 1], \\\\\"n_classes_\\\\\": 2, \\\\\"_le\\\\\": {\\\\\"classes_\\\\\": [0, 1]}, \\\\\"_estimator_type\\\\\": \\\\\"classifier\\\\\"}\"}, \"feature_names\": [], \"feature_types\": [], \"gradient_booster\": {\"model\": {\"trees\": [{\"base_weights\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"categories\": [], \"categories_nodes\": [], \"categories_segments\": [], \"categories_sizes\": [], \"default_left\": [true, true, true, true, true, true, true], \"id\": 0, \"left_children\": [1, 3, 5, -1, -1, -1, -1], \"loss_changes\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"parents\": [588197202, 0, 0, 1, 1, 2, 2], \"right_children\": [2, 4, 6, -1, -1, -1, -1], \"split_conditions\": [\"male\", 12.778438, 48.030862, 0.00425532, -0.13231800000000002, 0.055144000000000006, 0.18938100000000002], \"split_indices\": [2, 0, 1, 0, 0, 0, 0], \"split_type\": [1, 0, 0, 1, 1, 1, 1], \"sum_hessian\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"tree_param\": {\"num_deleted\": \"0\", \"num_feature\": \"4\", \"num_nodes\": \"7\", \"size_leaf_vector\": \"0\"}}, {\"base_weights\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"categories\": [], \"categories_nodes\": [], \"categories_segments\": [], \"categories_sizes\": [], \"default_left\": [true, true, true, true, true, true, true], \"id\": 1, \"left_children\": [1, 3, 5, -1, -1, -1, -1], \"loss_changes\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"parents\": [997849600, 0, 0, 1, 1, 2, 2], \"right_children\": [2, 4, 6, -1, -1, -1, -1], \"split_conditions\": [\"male\", 12.778438, 48.030862, 0.0038298100000000003, -0.11962800000000001, 0.049668800000000006, 0.17203200000000002], \"split_indices\": [2, 0, 1, 0, 0, 0, 0], \"split_type\": [1, 0, 0, 1, 1, 1, 1], \"sum_hessian\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"tree_param\": {\"num_deleted\": \"0\", \"num_feature\": \"4\", \"num_nodes\": \"7\", \"size_leaf_vector\": \"0\"}}, {\"base_weights\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"categories\": [], \"categories_nodes\": [], \"categories_segments\": [], \"categories_sizes\": [], \"default_left\": [true, true, true, true, true, true, true], \"id\": 2, \"left_children\": [1, 3, 5, -1, -1, -1, -1], \"loss_changes\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"parents\": [865841526, 0, 0, 1, 1, 2, 2], \"right_children\": [2, 4, 6, -1, -1, -1, -1], \"split_conditions\": [\"male\", 12.778438, 48.030862, 0.00344687, -0.108967, 0.044795100000000004, 0.158699], \"split_indices\": [2, 0, 1, 0, 0, 0, 0], \"split_type\": [1, 0, 0, 1, 1, 1, 1], \"sum_hessian\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"tree_param\": {\"num_deleted\": \"0\", \"num_feature\": \"4\", \"num_nodes\": \"7\", \"size_leaf_vector\": \"0\"}}, {\"base_weights\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"categories\": [], \"categories_nodes\": [], \"categories_segments\": [], \"categories_sizes\": [], \"default_left\": [true, true, true, true, true, true, true], \"id\": 3, \"left_children\": [1, 3, 5, -1, -1, -1, -1], \"loss_changes\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"parents\": [200216671, 0, 0, 1, 1, 2, 2], \"right_children\": [2, 4, 6, -1, -1, -1, -1], \"split_conditions\": [\"male\", \"Q\", 48.030862, -0.14433, -0.08975060000000001, 0.0404365, 0.148091], \"split_indices\": [2, 3, 1, 0, 0, 0, 0], \"split_type\": [1, 1, 0, 1, 1, 1, 1], \"sum_hessian\": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], \"tree_param\": {\"num_deleted\": \"0\", \"num_feature\": \"4\", \"num_nodes\": \"7\", \"size_leaf_vector\": \"0\"}}], \"tree_info\": [0, 0, 0, 0], \"gbtree_model_param\": {\"num_trees\": \"4\", \"size_leaf_vector\": \"0\"}}, \"name\": \"gbtree\"}, \"learner_model_param\": {\"base_score\": \"3.9134809E-01\", \"num_class\": \"0\", \"num_feature\": \"4\"}, \"objective\": {\"name\": \"binary:logistic\", \"reg_loss_param\": {\"scale_pos_weight\": \"1\"}}}, \"version\": [1, 4, 2]}'" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.to_json()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To export and save the model as a JSON file, specify a filename:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "model.to_json(\"exported_xgb_model.json\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike Python XGBoost, Vertica does not store some information like 'sum_hessian' or 'loss_changes,' and the exported model from to_json() replaces this information with a list of zeroes These information are replaced by a list filled with zeros." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Make Predictions with an Exported Model\n", "\n", "This exported model can be used with the Python XGBoost API right away, and exported models make identical predictions in Vertica and Python:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import xgboost as xgb\n", "model_python = xgb.XGBClassifier()\n", "model_python.load_model(\"exported_xgb_model.json\")\n", "y_test_vertica = model.to_python(return_proba = True)(X_test)\n", "y_test_python = model_python.predict_proba(X_test)\n", "result = (y_test_vertica - y_test_python) ** 2\n", "result = result.sum() / len(result)\n", "assert result == pytest.approx(0.0, abs = 1.0E-14)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For multiclass classifiers, the probabilities returned by the VerticaPy and the exported model may differ slightly because of normalization; while Vertica uses multinomial logistic regression, XGBoost Python uses Softmax. Again, this difference does not affect the model's final predictions. Categorical predictors must be encoded." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Clean the Example Environment\n", "\n", "Drop the 'xgb_to_json' schema, using CASCADE to drop any database objects stored inside (the 'titanic' table, the XGBoostClassifier model, etc.), then delete the 'exported_xgb_model.json' file: " ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DROP\n" ] }, { "data": { "text/html": [ "
Execution: 0.015s
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import os\n", "os.remove(\"exported_xgb_model.json\")\n", "vp.drop(\"xgb_to_json\", method = \"schema\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "VerticaPy lets you to create, train, evaluate, and export Vertica machine learning models. There are some notable nuances when importing a Vertica XGBoost model into Python XGBoost, but these do not affect the accuracy of the model or its predictions:\n", "\n", "