When we work on a machine learning project, quite often we need to experiment with multiple alternatives. Some features in Python allows us to try out different options without much effort. In this tutorial, we are going to see some tips to make our experiments faster.<\/p>\n
After finishing this tutorial, you will learn<\/p>\n
- \n
- How to leverage on duck-typing feature to easily swapping functions and objects<\/li>\n
- How making components drop-in replacement with each other can help experiments faster<\/li>\n<\/ul>\n
Let\u2019s get started.<\/p>\n
\n![\"\"](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2022\/02\/jake-givens-iR8m2RRo-z4-unsplash-scaled.jpg\")
<\/p>\nEasier experimenting in Python. Photo by Jake Givens<\/a>. Some rights reserved<\/p>\n<\/div>\n
Overview<\/h2>\n
This tutorial is in three parts, they are<\/p>\n
- \n
- Workflow of a machine learning project<\/li>\n
- Functions as objects<\/li>\n
- Caveats<\/li>\n<\/ul>\n
Workflow of a machine learning project<\/h2>\n
Consider a very simple machine learning project, as follows:<\/p>\n
from pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.svm import SVC\r\n\r\n# Load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/iris.csv\"\r\nnames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']\r\ndataset = read_csv(url, names=names)\r\n\r\n# Split-out validation dataset\r\narray = dataset.values\r\nX = array[:,0:4]\r\ny = array[:,4]\r\nX_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.20, random_state=1, shuffle=True)\r\n\r\n# Train\r\nclf = SVC()\r\nclf.fit(X_train, y_train)\r\n\r\n# Test\r\nscore = clf.score(X_val, y_val)\r\nprint(\"Validation accuracy\", score)<\/pre>\n
This is a typical machine learning project workflow. We have a stage of preprocessing of data, then training a model, and afterwards, evaluate our result. But in each step, we may want to try something different. For example, we may wonder if normalizing the data would make it better. So we may rewrite the code above into the following:<\/p>\n
from pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.svm import SVC\r\nfrom sklearn.pipeline import Pipeline\r\nfrom sklearn.preprocessing import StandardScaler\r\n\r\n# Load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/iris.csv\"\r\nnames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']\r\ndataset = read_csv(url, names=names)\r\n\r\n# Split-out validation dataset\r\narray = dataset.values\r\nX = array[:,0:4]\r\ny = array[:,4]\r\nX_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.20, random_state=1, shuffle=True)\r\n\r\n# Train\r\nclf = Pipeline([('scaler',StandardScaler()), ('classifier',SVC())])\r\nclf.fit(X_train, y_train)\r\n\r\n# Test\r\nscore = clf.score(X_val, y_val)\r\nprint(\"Validation accuracy\", score)<\/pre>\nSo far so good. But what if we keep experimenting with different dataset, different models, or different score functions? Each time, we keep flipping between using a scaler and not would mean a lot of code change, and quite easy to make mistakes.<\/p>\n
Because Python supports duck-typing, we can see that the following two classifier models implemented the same interface:<\/p>\n
clf = SVC()\r\nclf = Pipeline([('scaler',StandardScaler()), ('classifier',SVC())])<\/pre>\ntherefore, we can simply select between these two version and keep everything intact. We can say these two models are\u00a0drop-in replacement<\/strong>\u00a0of each other.<\/p>\n
Making use of this property, we can create a toggle variable to control the design choice we make:<\/p>\n
USE_SCALER = True\r\n\r\nif USE_SCALER:\r\n clf = Pipeline([('scaler',StandardScaler()), ('classifier',SVC())])\r\nelse:\r\n clf = SVC()<\/pre>\nby toggling the variable\u00a0
USE_SCALER<\/code>\u00a0between\u00a0True<\/code>\u00a0and\u00a0False<\/code>, we can select whether a scaler should be applied. A more complex example would be to select among different scaler and the classifier models, such as<\/p>\nSCALER = \"standard\"\r\nCLASSIFIER = \"svc\"\r\n\r\nif CLASSIFIER == \"svc\":\r\n model = SVC()\r\nelif CLASSIFIER == \"cart\":\r\n model = DecisionTreeClassifier()\r\nelse:\r\n raise NotImplementedError\r\n\r\nif SCALER == \"standard\":\r\n clf = Pipeline([('scaler',StandardScaler()), ('classifier',model)])\r\nelif SCALER == \"maxmin\":\r\n clf = Pipeline([('scaler',MaxMinScaler()), ('classifier',model)])\r\nelif SCALER == None:\r\n clf = model\r\nelse:\r\n raise NotImplementedError<\/pre>\nA complete example is as follows:<\/p>\n
from pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.svm import SVC\r\nfrom sklearn.tree import DecisionTreeClassifier\r\nfrom sklearn.pipeline import Pipeline\r\nfrom sklearn.preprocessing import StandardScaler, MinMaxScaler\r\n\r\n# toggle between options\r\nSCALER = \"maxmin\" # \"standard\", \"maxmin\", or None\r\nCLASSIFIER = \"cart\" # \"svc\" or \"cart\"\r\n\r\n# Load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/iris.csv\"\r\nnames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']\r\ndataset = read_csv(url, names=names)\r\n\r\n# Split-out validation dataset\r\narray = dataset.values\r\nX = array[:,0:4]\r\ny = array[:,4]\r\nX_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.20, random_state=1, shuffle=True)\r\n\r\n# Create model\r\nif CLASSIFIER == \"svc\":\r\n model = SVC()\r\nelif CLASSIFIER == \"cart\":\r\n model = DecisionTreeClassifier()\r\nelse:\r\n raise NotImplementedError\r\n\r\nif SCALER == \"standard\":\r\n clf = Pipeline([('scaler',StandardScaler()), ('classifier',model)])\r\nelif SCALER == \"maxmin\":\r\n clf = Pipeline([('scaler',MinMaxScaler()), ('classifier',model)])\r\nelif SCALER == None:\r\n clf = model\r\nelse:\r\n raise NotImplementedError\r\n\r\n# Train\r\nclf.fit(X_train, y_train)\r\n\r\n# Test\r\nscore = clf.score(X_val, y_val)\r\nprint(\"Validation accuracy\", score)<\/pre>\n<\/p>\nFunctions as objects<\/h2>\n
In Python, functions are first-class citizens. You can assign functions to a variable. Indeed, functions are objects in Python, so as classes (the classes themselves, not only incarnations of classes). Therefore, we can use the same technique as above to experiment amongst similar functions.<\/p>\n
import numpy as np\r\n\r\nDIST = \"normal\"\r\n\r\nif DIST == \"normal\":\r\n rangen = np.random.normal\r\nelif DIST == \"uniform\":\r\n rangen = np.random.uniform\r\nelse:\r\n raise NotImplementedError\r\n\r\nrandom_data = rangen(size=(10,5))\r\nprint(random_data)<\/pre>\n
The above is similar to calling\u00a0
np.random.normal(size=(10,5))<\/code>\u00a0but we hold the function in a variable for the convenience of swaping one function with another. Note that since we call the functions with the same argument, we have to make sure all variations will accept it. In case it is not, we may need some additional lines of code to make a wrapper. For example, in case of generating Student\u2019s t distribution, we need an additional parameter for the degree of freedom:<\/p>\nimport numpy as np\r\n\r\nDIST = \"t\"\r\n\r\nif DIST == \"normal\":\r\n rangen = np.random.normal\r\nelif DIST == \"uniform\":\r\n rangen = np.random.uniform\r\nelif DIST == \"t\":\r\n def t_wrapper(size):\r\n # Student's t distribution with 3 degree of freedom\r\n return np.random.standard_t(df=3, size=size)\r\n rangen = t_wrapper\r\nelse:\r\n raise NotImplementedError\r\n\r\nrandom_data = rangen(size=(10,5))\r\nprint(random_data)<\/pre>\n
This works because in the above,\u00a0
np.random.normal<\/code>,\u00a0np.random.uniform<\/code>, and\u00a0t_wrapper<\/code> as we defined are all drop-in replacement of each other.<\/p>\nCaveats<\/h2>\n
Machine learning differs from other programming projects because there are more uncertainties in the workflow. When you build a web page, or build a game, you have a picture in your mind on what to achieve. But there are some exploratory work in machine learning projects.<\/p>\n
You will probably use some source code control system like git or Mercurial to manage your source code development history in other projects. In machine learning projects, however, we are trying out different\u00a0combinations<\/strong> of many steps. Using git to manage the different variations may not fit, not to say sometimes overkill. Therefore using a toggle variable to control the flow should allow us try out different things faster. This is especially handy when we are working on our projects in Jupyter notebooks.<\/p>\n
However, as we put multiple versions of code together, we made the program clumsy and less readable. It is better to do some clean up after we confirmed with what to do. This will help us in maintenance into the future.<\/p>\n
Further reading<\/h2>\n
This section provides more resources on the topic if you are looking to go deeper.<\/p>\n
Books<\/h4>\n
- \n
- Fluent Python, second edition, by Luciano Ramalho,\u00a0https:\/\/www.amazon.com\/dp\/1492056359\/<\/a>\n<\/li>\n<\/ul>\n
Summary<\/h2>\n
In this tutorial, you\u2019ve see how duck-typing property in Python help us create drop-in replacements. Specifically you learned<\/p>\n
- \n
- Duck-typing can help us switch between alternatives easily in a machine learning workflow<\/li>\n
- We can make use a toggle variable to experiment among alternatives<\/li>\n<\/ul>\n
The post Easier experimenting in Python<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n
Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
- Fluent Python, second edition, by Luciano Ramalho,\u00a0https:\/\/www.amazon.com\/dp\/1492056359\/<\/a>\n<\/li>\n<\/ul>\n