diff options
Diffstat (limited to 'notebooks/SVM.ipynb')
| -rw-r--r-- | notebooks/SVM.ipynb | 560 |
1 files changed, 560 insertions, 0 deletions
diff --git a/notebooks/SVM.ipynb b/notebooks/SVM.ipynb new file mode 100644 index 0000000..e1255b5 --- /dev/null +++ b/notebooks/SVM.ipynb @@ -0,0 +1,560 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "2a386f10", + "metadata": {}, + "outputs": [], + "source": [ + "from sunlab.globals import FILES" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6eab6d52-54ac-44ed-9bda-7117cba37c87", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['TF_CPP_MIN_LOG_LEVEL'] = \"3\"\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = \"-1\"\n", + "\n", + "# import tensorflow as tf\n", + "# tf.autograph.set_verbosity(0, False)\n", + "# from matplotlib import pyplot as plt\n", + "\n", + "import joblib\n", + "try:\n", + " import sklearn.externals.joblib as extjoblib\n", + "except:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ff998f7-2bd5-41d6-a397-b74f7238d225", + "metadata": {}, + "outputs": [], + "source": [ + "def load_model(model_pkl_path, scaler_pkl_path):\n", + " clf = joblib.load(model_pkl_path)\n", + " scaler = joblib.load(scaler_pkl_path)\n", + " return clf, scaler" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ce9834f6-1787-409d-85c5-fea51e130368", + "metadata": {}, + "outputs": [], + "source": [ + "def load_test_data(data, d=1, pixel2dist = 1.075268):\n", + " from transform_data import Add_Measures, Exclude_Measures\n", + " \"\"\"\n", + " Encapsulates SVM_csv.py\n", + "\n", + " Inputs:\n", + " data_path: path to CSV data you wish to be evaluated\n", + " write_txt: write text file with probabilities etc.\n", + " d: dimensionality to which increase features. If d=2, quadratic, cross features are included.\n", + "\n", + " Outputs:\n", + " Nothing, as of yet.\n", + " \"\"\"\n", + "# data = dataset.dataframe[dataset.data_columns].to_numpy()\n", + "# pixel2dist = 1.075268\n", + " #pixel2dist=0.53763672 #microns/pixel using 20x oil objective lens on confocal\n", + " #pixel2dist=0.656265 #using 20x oil lens, microns/pixel on dark room microscope\n", + " #pixel2dist=1.075268 #using 10x air objective on the confocal\n", + "\n", + " print('Data is being converted to correct micrometers, assuming measured in pixels')\n", + " #scale columns by following\n", + " data[:,0] =data[:,0]*pixel2dist*pixel2dist#area\n", + " data[:,1] = data[:,1]*pixel2dist#majoraxislength\n", + " data[:,2] = data[:,2]*pixel2dist#minoraxislength\n", + " #3 is eccentricity, unitless\n", + " data[:,4] =data[:,4]*pixel2dist*pixel2dist#4 convex area,\n", + " data[:,5] = data[:,5]*pixel2dist#5 Equiv diam\n", + " #6 solidity, unitless\n", + " #7 extent, unitless\n", + " data[:,8] = data[:,8]*pixel2dist#8 Perimeter\n", + " data[:,9] = data[:,9]*pixel2dist#9 Convex Perimeter\n", + " data[:,10] = data[:,10]*pixel2dist#10 Fiber Length\n", + " data[:,11] = data[:,11]*pixel2dist#11 Max Inscribed Radius\n", + " data[:,12] = data[:,12]*pixel2dist#12 Bleb_length\n", + "\n", + "\n", + " #add form factor as last column of data?\n", + " #Form factor is added inside the Processing data when doing SVM. See \"Transform_data.py\"\n", + "\n", + " #if len(Measure_Delete)>0:\n", + " #\tdata = np.delete(data, Measure_Delete, axis = 1) #delete time column and cellnumber column, since we already have them.\n", + "\n", + " #so now data should look just like other data used in SVM\n", + "\n", + " #add aspect ratio as last column of data\n", + " X_data = Add_Measures(data, add_AR=True, add_FF=True, add_convexity=True,\n", + " add_curl_old=True, add_curl=True, add_sphericity=True,\n", + " add_InscribedArea=True, add_BlebRel=True)\n", + " #if you wish to exclude certain measures:\n", + " #Area,MjrAxis,MnrAxis,Ecc,ConA,EqD,Sol,Ext,Per,conPer,FL,InR,bleb_M\n", + " X_data = Exclude_Measures(X_data, ex_Area=False,\n", + " ex_MjrAxis=False, ex_MnrAxis=False, ex_Ecc=False,\n", + " ex_ConA=False, ex_EqD=False, ex_Sol=False, ex_Ext=False,\n", + " ex_Per=False,ex_conPer=False,ex_FL=False,ex_InR=False,\n", + " ex_bleb=False)\n", + "\n", + " ####IF THE DATA WAS POLYNOMIAL BEFORE SCALED, DO THAT NOW!\n", + " #frameinfo = getframeinfo(currentframe())\n", + " #print(\"IF YOUR SCALER IS A POLYNOMIAL, YOU NEED TO EDIT THE POLYNOMIAL FEATURES, LINE %d CODE\" % (frameinfo.lineno + 2))\n", + " #d = 1\n", + " if d==2:\n", + " print(\"Expanding feature set to include quadratic, cross terms.\")\n", + " poly=preprocessing.PolynomialFeatures(degree = d, interaction_only = True)\n", + " X_data_exp = poly.fit_transform(X_data)\n", + "\n", + " #FIRST, SCALE THE DATA USING THE SCALER\n", + " X_data_scaled = scaler.transform(X_data_exp)\n", + " else:\n", + " X_data_scaled = scaler.transform(X_data)\n", + "\n", + " #GATHER PROBABILITIES\n", + " Probs = clf.predict_proba(X_data_scaled)\n", + "\n", + " #Gather Predictions\n", + " Predictions = clf.predict(X_data_scaled)\n", + "\n", + " Descriptors = ['frame', 'cellnumber','x-cent','y-cent','actinedge','filopodia','bleb','lamellipodia']\n", + " return Probs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ee0a154e-4a09-44a9-b32a-2793f513d632", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:35: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:597: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:836: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:862: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps, positive=False):\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1097: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1344: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " max_n_alphas=1000, n_jobs=None, eps=np.finfo(np.float).eps,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/least_angle.py:1480: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps, copy_X=True, positive=False):\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:152: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " precompute=False, eps=np.finfo(np.float).eps,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:320: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=np.finfo(np.float).eps, random_state=None,\n", + "/home/physics/cunnichr/.micromamba/envs/svm/lib/python3.7/site-packages/sklearn/linear_model/randomized_l1.py:580: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " eps=4 * np.finfo(np.float).eps, n_jobs=None,\n" + ] + } + ], + "source": [ + "model_pkl_path = FILES[\"SVM\"][\"MODEL\"]\n", + "scaler_pkl_path = FILES[\"SVM\"][\"SCALER\"]\n", + "clf, scaler = load_model(model_pkl_path, scaler_pkl_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f54208e2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b84f9486", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f6287849", + "metadata": {}, + "outputs": [], + "source": [ + "from sunlab.common.data import *\n", + "from numpy import savetxt" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "a44df4f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data is being converted to correct micrometers, assuming measured in pixels\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/physics/cunnichr/NewKeras/sunlab/code/sunlab/common/data/dataset.py:72: RuntimeWarning: No classification labels found for the dataset\n", + " RuntimeWarning)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "p2d = 1.075268/4\n", + "fname = FILES[\"HISTOLOGIES\"][\"J1\"]\n", + "data = import_dataset(fname, 40, scaler=None)\n", + "# Ignore dirty masks from brush effects in masking process\n", + "df = data.dataframe[data.dataframe['Area']>350]\n", + "ds = df[data.data_columns].to_numpy()\n", + "out_data = load_test_data(ds, pixel2dist=p2d)\n", + "columns = [\"frame\", \"cellnumber\", \"x-cent\", \"y-cent\", \"actinedge\", \"filopodia\", \"bleb\", \"lamellipodia\"]\n", + "out = np.hstack([df[['Frames','CellNum','CenterX','CenterY']].to_numpy(), out_data])\n", + "savetxt(fname[:-3] + \"txt\", out, comments=\"\", header=\" \".join(columns))" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "f3df960c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/physics/cunnichr/NewKeras/sunlab/code/sunlab/common/data/dataset.py:72: RuntimeWarning: No classification labels found for the dataset\n", + " RuntimeWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data is being converted to correct micrometers, assuming measured in pixels\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "p2d = 1.075268/4\n", + "fname = FILES[\"HISTOLOGIES\"][\"H9\"]\n", + "data = import_dataset(fname, 40, scaler=None)\n", + "df = data.dataframe\n", + "ds = df[data.data_columns].to_numpy()\n", + "out_data = load_test_data(ds, pixel2dist=p2d)\n", + "columns = [\"frame\", \"cellnumber\", \"x-cent\", \"y-cent\", \"actinedge\", \"filopodia\", \"bleb\", \"lamellipodia\"]\n", + "out = np.hstack([df[['Frames','CellNum','CenterX','CenterY']].to_numpy(), out_data])\n", + "savetxt(fname[:-3] + \"txt\", out, comments=\"\", header=\" \".join(columns))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9adcb164", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data is being converted to correct micrometers, assuming measured in pixels\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/physics/cunnichr/NewKeras/sunlab/code/sunlab/common/data/dataset.py:72: RuntimeWarning: No classification labels found for the dataset\n", + " RuntimeWarning)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "p2d = 1.075268/4\n", + "fname = FILES[\"HISTOLOGIES\"][\"H4\"]\n", + "data = import_dataset(fname, 40, scaler=None)\n", + "df = data.dataframe\n", + "ds = df[data.data_columns].to_numpy()\n", + "out_data = load_test_data(ds, pixel2dist=p2d)\n", + "columns = [\"frame\", \"cellnumber\", \"x-cent\", \"y-cent\", \"actinedge\", \"filopodia\", \"bleb\", \"lamellipodia\"]\n", + "out = np.hstack([df[['Frames','CellNum','CenterX','CenterY']].to_numpy(), out_data])\n", + "savetxt(fname[:-3] + \"txt\", out, comments=\"\", header=\" \".join(columns))" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "546563f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data is being converted to correct micrometers, assuming measured in pixels\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/physics/cunnichr/NewKeras/sunlab/code/sunlab/common/data/dataset.py:72: RuntimeWarning: No classification labels found for the dataset\n", + " RuntimeWarning)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "p2d = 1.075268/4\n", + "fname = FILES[\"HISTOLOGIES\"][\"image001\"]\n", + "data = import_dataset(fname, 40, scaler=None)\n", + "df = data.dataframe\n", + "# Ignore bad mask\n", + "df = df[df['Perimeter'] < 8500]\n", + "ds = df[data.data_columns].to_numpy()\n", + "out_data = load_test_data(ds, pixel2dist=p2d)\n", + "columns = [\"frame\", \"cellnumber\", \"x-cent\", \"y-cent\", \"actinedge\", \"filopodia\", \"bleb\", \"lamellipodia\"]\n", + "out = np.hstack([df[['Frames','CellNum','CenterX','CenterY']].to_numpy(), out_data])\n", + "savetxt(fname[:-3] + \"txt\", out, comments=\"\", header=\" \".join(columns))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "602386e0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46571673", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1df5e089", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "104272f1", + "metadata": {}, + "outputs": [], + "source": [ + "SAVE_OUT = False" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "321d7062-e2e0-4fed-bf48-ea8f96901be4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data is being converted to correct micrometers, assuming measured in pixels\n" + ] + } + ], + "source": [ + "from numpy import loadtxt, savetxt\n", + "data = loadtxt(FILES[\"PHENOTYPE_GRID\"][\"IN\"])\n", + "classes = load_test_data(data)\n", + "if SAVE_OUT:\n", + " savetxt(FILES[\"PHENOTYPE_GRID\"][\"OUT\"], classes)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b0669eb5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(250000,)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from numpy import argmax\n", + "im_classes = argmax(classes, axis=-1)\n", + "im_classes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "cb4b0a78", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x2aabb1036d10>" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "from sunlab.common.plotting.colors import Pmap\n", + "plt.imshow(im_classes.reshape((500,500)).T, cmap=Pmap, origin='lower')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "394f4fdc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"TRAINING_DATASET\": \"../../data/spheroid26_011523_filtered.csv\",\n", + " \"TRAINING_DATASET_WIDE_BERTH\": \"../../data/spheroid26_011523_exc.csv\",\n", + " \"PRETRAINED_MODEL_DIR\": \"../../models/current_model/\",\n", + " \"PEN_TRACKED\": {\n", + " \"AUTO\": \"../../data/PEN_automatically_tracked.csv\",\n", + " \"MANUAL\": \"../../data/PEN_manually_tracked.csv\"\n", + " },\n", + " \"RHO\": {\n", + " \"3\": \"../../data/Rho_act_Cell3.csv\",\n", + " \"4\": \"../../data/Rho_act_Cell4.csv\",\n", + " \"6\": \"../../data/Rho_act_Cell6.csv\",\n", + " \"7\": \"../../data/Rho_act_Cell7.csv\",\n", + " \"8\": \"../../data/Rho_act_Cell8.csv\",\n", + " \"9\": \"../../data/Rho_act_Cell9.csv\",\n", + " \"10\": \"../../data/Rho_act_Cell10.csv\",\n", + " \"11\": \"../../data/Rho_act_Cell11.csv\"\n", + " },\n", + " \"SPHEROID\": {\n", + " \"1p5mgml\": \"../../data/spheroid26_011523_filtered.csv\",\n", + " \"3mgml\": \"../../data/spheroid20_011923_filtered.csv\",\n", + " \"4mgml\": \"../../data/spheroid22_012323_filtered.csv\",\n", + " \"6mgml\": \"../../data/spheroid26_012423_filtered.csv\"\n", + " },\n", + " \"FIGURES\": {\n", + " \"2\": {\n", + " \"PHENOTYPES_SMOOTHED\": \"../../extra_data/PhenotypeGaussianSmoothed.npy\"\n", + " },\n", + " \"3\": {\n", + " \"SAMPLED_DATASET\": \"../../extra_data/Figure3.SampledDataset.npy\",\n", + " \"PAIRWISE_DISTANCES\": \"../../extra_data/Figure3.PairwiseDistances.npy\",\n", + " \"PAIRWISE_DOT_PRODUCTS\": \"../../extra_data/Figure3.PairwiseDotProducts.npy\",\n", + " \"TRAJECTORIES\": \"../../extra_data/Figure3.Trajectories.npy\"\n", + " }\n", + " },\n", + " \"PHENOTYPE_GRID\": {\n", + " \"IN\": \"../../extra_data/PhenotypeGrid.npy\",\n", + " \"OUT\": \"../../extra_data/PhenotypeGrid_out.npy\"\n", + " },\n", + " \"PHENOTYPE_RGB\": \"../../extra_data/PhenotypeColors.npy\",\n", + " \"SVM\": {\n", + " \"MODEL\": \"../../other/svm/SVC_rbf_010820_16942_new.pkl\",\n", + " \"SCALER\": \"../../other/svm/SVC_rbf_scaler_010820_16942_new.pkl\"\n", + " },\n", + " \"NONPHYSICAL_MASK\": \"../../extra_data/NonPhysicalMask.npy\"\n", + "}\n" + ] + } + ], + "source": [ + "from json import dumps\n", + "print(dumps(FILES,indent=4))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31cf538e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "svm", + "language": "python", + "name": "svm" + }, + "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.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} |