Scikit-learn enables allows for the transformation of categorical data into quantitative data which can be used in machine learning model training. However, an important thing to note about LabelEncoder is that it will transform your categorical data into ordinal numbers which may cause your model interpret do believe there are relationships between unrelated categories.

University of Michigan - Ann Arbor

In order to avoid the problem of false assumed relationships present with LabelEncoder, you can use OneHotEncoder to transform a column into a series of columns where each column represents the binary choice of 'did the original column contain value x'. This prevents the creation of false ordinal relationship. However, OneHotEncoder only takes columns of integer values greater than 1, but you can easily transform categorical variables using LabelEncoder or pd.get_dummies

sklearn.preprocessing.OneHotEncoder

Some helpful sklearn functions include:

- KNeighborsClassifier

- DummyClassifier

- DummyRegressor

- LabelEncoder

- OneHotEncoder

- Train Test Split Function

- make_regression

- make_friedman1

- make_classification

- SVC

- DecisionTreeClassifier

- RandomForestClassifier

- RandomForestRegressor

- GridSearchCV


Helpful Scikit-Learn functions

https://scikit-learn.org/stable/user_guide.html

Scikit-learn Documentation

sklearn.preprocessing.LabelEncoder

Link: [kaggle.com](https://www.kaggle.com/dansbecker/using-categorical-data-with-one-hot-encoding) 

One hot encoding picture

The `pandas.get_dummies()` function is used to convert categorical variables into binary indicator columns. To apply categorical imputation, the `dummy_na=True` argument can be passed, which instructs the function to treat `NaN` as a valid category and generate a dedicated dummy column to explicitly flag missing entries.

pandas.get_dummies

Scikit-learn enables the creation of classifier objects. For example, 
```python
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors = 5, weights = 'distance')
```
In this example, the classifier object (named knn) will consider 5 neighbors in its kneighbors queries.   Setting the weights parameter to 'distance' means that closer neighbors will be more influential than those farther away  (in terms of detemrining which category the "target" point belongs to).

sklearn.neighbors.KNeighborsClassifier

Scikit-learn allows for dummy classifiers to be created for the purpose of comparing to a statistically generated model

```
dummy = DummyClassifier(strategy="most_frequent")
```

This code creates a dummy classifier which predicts every value to hold the same value as the most frequent value in the training set. 

sklearn.dummy.DummyClassifier

This function randomly shuffles the dataset and splits off a certain percentage of the input samples for use as a training set, and then puts the remaining samples into a different variable for use as a test set. So in this example, we're using a 75-25% split of training versus test data. And that's a pretty standard relative split that's used. It's a good rule of thumb to use in deciding what proportion of training versus test might be helpful.
```
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
```
- Unless optional parameters test_size or train_size are passed in, the method will subset the training and test data randomly into 75% train:25% test
- random_state is an optional parameter used for reproducible output across multiple function calls

Train Test Split Function

Generates a dataset for a random regression problem. The generated dataset will be made of simulated inputs and target values based on a random linear regression model.

sklearn.datasets.make_regression

Generates the Friedman #1 regression problem. The X values will be uniformly distributed over [0,1] and the y output will be distributed according to 
```
y(X) = 10 * sin(pi * X[:,1] + 20 * (X[:,2] - 0.5) **2 + 10 * X[:,3} + 5 * X[:,4] + noise * N(0,1)
```

sklearn.datasets.make_friedman1

Generates a random classification problem. Some of the things we can specify through its parameters are the number of samples, number of classes, number of features, etc. The function returns the generated samples in an array of shape [n_samples, n_features]. It also returns an array of shape [n_samples], containing the integer labels for class membership of each sample.

sklearn.datasets.make_classification

This function creates a support vector classifier (SVC) object. Two important parameters are:
- C: Regularization parameter. In other words, this controls the cost of misclassification on the training data.
- kernel: specifies the kernel type to be used in the algorithm. This parameter can be set to "linear", "poly", "rbf", "sigmoid", or "precomputed"

sklearn.svm.SVC

Function that creates a decision tree classifier. Decision trees predict the target variable value by learning decision rules that are deduced from the data features. Some useful parameters include splitter (split strategy to use) and max_depth (maximum depth of the tree). 

sklearn.tree.DecisionTreeClassifier

Creates a random forest classifier. It will fit a number of decision tree classifiers on subsets of the data and then apply averaging over the sub-samples to improve accuracy and reduce overfitting.

 sklearn.ensemble.RandomForestClassifier

The DummyRegressor is similar to the DummyClassifier. While a DummyClassifier can serve as a baseline for comparison with real classifiers, a DummyRegressors can serve as a baseline for comparison with real regressors. 

sklearn.dummy.DummyRegressor

Performs hyperparameter tuning to determine the optimal values for the input model. Some parameters are estimator: the model we want to use for the hyperparameter tuning process, and param_grid: a dictionary in which the keys are the hyperparameters, and their corresponding values are a list of values that parameter can take.

sklearn.model_selection.GridSearchCV

Function that creates a random forest regressor. The random forest regressor uses a number of decision trees that are each trained on different subsets of the dataset. The final output is the mean of the outputs from the decision trees.

sklearn.ensemble.RandomForestRegressor

from sklearn.model_selection import cross_val_score
cv_scores = cross_val_score(clf, X, y, cv)

clf is the model we want to evaluate, X is the data set, y is the corresponding ground truth target labels or values, cv is the number of folds.

By default, cross_val_score does threefold cross-validation, which will return a list of three accuracy scores, one for each of the three folds. We can take the mean value as the accuracy of the model on average.

Learn Before

Related