Showing posts with label Classification. Show all posts

About Machine Learning 1

Machine Learning

The Machine Learning Landscape
Classification
Support Vector Machines
Decision Trees
Ensemble Learning and Random Forests
Dimensionality Reduction
Clustering

👉YouTube Link: https://www.youtube.com/@drrambabupemula

👉 Machine Learning 1 Syllabus

Unit I:

The Machine Learning Landscape: What Is Machine Learning? Why Use Machine Learning? Types of Machine Learning Systems, Supervised/Unsupervised Learning, Batch and Online Learning, Instance-Based Versus Model-Based Learning, Main Challenges of Machine Learning, Insufficient Quantity of Training Data, Nonrepresentative Training Data, Poor-Quality Data, Irrelevant Features, Overfitting the Training Data, Underfitting the Training Data, Stepping Back, Testing and Validating.

👉UNIT 1(A) NOTEs : The Machine Learning Landscape Notes

👉UNIT 1(A) PPTs: The Machine Learning Landscape

👉UNIT 1(B) NOTEs: The Machine Learning Landscape NOTEs

👉Machine Learning 1 : UNIT 1(B) PPTs: The Machine Learning Landscape PPTs

👉Machine Learning 1: UNIT 1 The Machine Learning Landscape Questions

Unit II:

Classification: Training a Binary Classifier, Performance Measures, Measuring Accuracy UsingCross-Validation, Confusion Matrix, Precision and Recall, Precision/RecallTradeoff , The ROC Curve, Multiclass Classification, Error Analysis, Multilabel Classification, Multi Output Classification. k-NN Classifier.

👉Machine Learning 1: UNIT 2 NOTEs: Classification Notes

👉Machine Learning 1 : UNIT 2: Classification PPTs

👉Machine Learning 1: UNIT 2: Classification MCQs

👉Machine Learning 1: UNIT 2: Classification Questions

Unit III:

Support Vector Machines: Linear SVM Classification, Soft Margin Classification, Nonlinear SVM Classification, Polynomial Kernel, Adding Similarity Features, Gaussian RBF Kernel, Computational Complexity, SVM Regression, Under the Hood, Decision Function and Predictions, Training Objective, Quadratic Programming, The Dual Problem, Kernelized SVM, Online SVMs.

👉Machine Learning 1: UNIT 3 (A) NOTES: Support Vector Machines NOTEs

👉Machine Learning 1: UNIT 3 (A) PPTs: Support Vector Machines PPTs

👉Machine Learning 1: UNIT 3 (B) NOTEs: Support Vector Machines NOTEs

👉Machine Learning 1: UNIT 3 (B) PPTs: Support Vector Machines PPTs

👉Machine Learning 1: UNIT 3 A & B : Support Vector Machines Questions

👉Machine Learning 1: UNIT 3 : Support Vector Machines MCQs

Unit IV:

Decision Trees: Training and Visualizing a Decision Tree, Making Predictions, Estimating Class Probabilities, The CART Training Algorithm, Computational Complexity, Gini Impurity or Entropy? Regularization Hyperparameters, Regression

👉Machine Learning 1: UNIT 4 (A) NOTEs: Decision Trees NOTEs

👉Machine Learning 1: UNIT 4 (A) PPTs: Decision Trees PPTs

👉Machine Learning 1: UNIT 4 (A): Decision Trees Questions

👉Machine Learning 1: UNIT 4 (A) : Decision Trees MCQs

Ensemble Learning and Random Forests: Voting Classifiers, Bagging and Pasting, Bagging and Pasting in Scikit-Learn, Out-of-Bag Evaluation, Random Patches and Random Subspaces, Random Forests, Extra-Trees, Feature Importance, Boosting, AdaBoost, Gradient Boosting, Stacking.

👉Machine Learning 1: UNIT 4 (B) NOTES: Ensemble Learning and Random Forests NOTES

👉Machine Learning 1: UNIT 4 (B) PPTs: Ensemble Learning and Random Forests PPTs

👉Machine Learning 1: UNIT 4 (B) : Ensemble Learning and Random Forests Questions

👉Machine Learning 1: UNIT 4 (B) : Ensemble Learning and Random Forests MCQs

Unit V:

Dimensionality Reduction: The Curse of Dimensionality, Main Approaches for Dimensionality Reduction, Projection, PCA.

👉Machine Learning 1: UNIT-5(A) NOTES: Dimensionality Reduction NOTES

👉Machine Learning 1: UNIT-5(A) PPTs: Dimensionality Reduction PPTs

👉Machine Learning 1: UNIT-5(A): Dimensionality Reduction Questions

Clustering: How does clustering work: finding similarities using distances, Euclidean distance and other distance metrics. k-Means Clustering: Plotting customers with their segments, normalizing features, cluster centres and interpreting the Clusters. Hierarchical Clustering.

👉Machine Learning 1: UNIT 5(B) NOTEs: Clustering NOTES

👉Machine Learning 1: UNIT 5 (B) PPTs: Clustering PPTs

👉Machine Learning 1: UNIT 5 (B) : Clustering Questions

Textbooks:

1. Géron, Aurélien. Hands-on machine learning with Scikit-Learn, Keras, and TensorFlow: Concepts, tools, and techniques to build intelligent systems. O'Reilly Media, 2019.

2. Pradhan, Manaranjan, and U. Dinesh Kumar. Machine Learning using Python. Wiley, IIM Bangalore, 2019.

References:

1. Introduction to Machine Learning, Ethem Alpaydin 2nd Edition, MIT Press 2000

2. Machine Learning, Tom M. Mitchell, McGraw Hill, 1997, ISBN: 0-07-042807-7.

Machine Learning 1 Syllabus

Machine Learning

Syllabus

Unit I:

Unit II:

Classification: Training a Binary Classifier, Performance Measures, Measuring Accuracy Using Cross-Validation, Confusion Matrix, Precision and Recall, Precision/Recall Tradeoff, The ROC Curve, Multiclass Classification, Error Analysis, Multilabel Classification, Multi Output Classification. k-NN Classifier.

Unit III:

Unit IV:

Unit V:

Dimensionality Reduction: The Curse of Dimensionality, Main Approaches for Dimensionality Reduction, Projection, PCA.

Textbooks:

1. Géron, Aurélien. Hands-on machine learning with Scikit-Learn, Keras, and TensorFlow: Concepts, tools, and techniques to build intelligent systems. O'Reilly Media, 2019.

2. Pradhan, Manaranjan, and U. Dinesh Kumar. Machine Learning using Python. Wiley, IIM Bangalore, 2019.

References:

1. Introduction to Machine Learning, Ethem Alpaydin 2nd Edition, MIT Press 2000

2. Machine Learning, Tom M. Mitchell, McGraw Hill, 1997, ISBN: 0-07-042807-7.

About Machine Learning

Machine Learning

👉 About Machine Learning 1

The Machine Learning Landscape
Classification
Support Vector Machines
Decision Trees
Ensemble Learning and Random Forests
Dimensionality Reduction
Clustering
👉 YouTube Link: https://www.youtube.com/@drrambabupemula

👉 About Machine Learning 2

👉 About Machine Learning 3

Introduction
Data Pre-processing
Performance measurement of models
Supervised Learning
Decision Tree Learning
Unsupervised Learning
Ensemble Models

👉 Machine Learning MCQs

👉 Machine Learning Programs

Measuring Accuracy Using Cross-Validation

Measuring Accuracy Using Cross-Validation

• A good way to evaluate a model is to use cross-validation.

• Let’s use the cross_val_score() function to

ü evaluate our SGDClassifier model,

· using K-fold cross-validation with three folds.

• Remember that K-fold cross-validation means

ü splitting the training set into K folds (in this case, three), then

· making predictions and

· evaluating them on each fold using

ü a model trained on the remaining folds.

from sklearn.model_selection import cross_val_score

cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring="accuracy")

array([0.96355, 0.93795, 0.95615])

ü Above 93% accuracy (ratio of correct predictions) on all cross-validation folds?

ü This looks amazing, doesn’t it?

ü let’s look at a very dumb classifier that just classifies every single image in the “not-5” class:

from sklearn.base import BaseEstimator

class Never5Classifier(BaseEstimator):

def fit(self, X, y=None):

return self

def predict(self, X):

return np.zeros((len(X), 1), dtype=bool)

ü Can you guess this model’s accuracy?

ü Let’s find out:

never_5_clf = Never5Classifier()

cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring="accuracy")

array([0.91125, 0.90855, 0.90915])

· It has over 90% accuracy!

· This is simply because

ü only about 10% of the images are 5s,

ü so if you always guess that an image is not a 5,

• you will be right about 90% of the time.

• This demonstrates why accuracy is

• generally not the preferred performance measure for classifiers,

ü especially when you are dealing with skewed datasets

ü i.e., when some classes are much more frequent than others.

• Implementing Cross-Validation

ü Occasionally you will need more control over the cross-validation process than what Scikit-Learn provides off the shelf.

ü In these cases, you can implement cross-validation yourself.

WEEK 9 - Write a program to implement SVM algorithm to classify the iris data set. Print both correct and wrong predictions.

Classification of Iris flowers using Random Forest

Steps:

1. Importing the library files
2. Reading the Iris Dataset
3. Preprocessing
4. Split the dataset into training and testing
5. Build the model (Random Forest Model)
6. Evaluate the performance of the Model

1. Importing the library files



2. Reading the Iris Dataset







3. Preprocessing







4. Split the dataset into training and testing




5. Build the model (Random Forest Model)

sklearn.ensemble.RandomForestClassifier
class sklearn.ensemble.RandomForestClassifier(n_estimators=100, *, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='sqrt', max_leaf_nodes=None, min_impurity_decrease=0.0, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None)

A random forest classifier.
A random forest is a meta estimator that fits a number of decision tree classifiers on various sub-samples of the dataset and uses averaging to improve the predictive accuracy and control over-fitting. The sub-sample size is controlled with the max_samples parameter if bootstrap=True (default), otherwise the whole dataset is used to build each tree.
Parameters:
n_estimatorsint, default=100
The number of trees in the forest.
criterion{“gini”, “entropy”, “log_loss”}, default=”gini”
The function to measure the quality of a split. Supported criteria are “gini” for the Gini impurity and “log_loss” and “entropy” both for the Shannon information gain.
max_depthint, default=None
The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.
min_samples_splitint or float, default=2
The minimum number of samples required to split an internal node:
If int, then consider min_samples_split as the minimum number.
If float, then min_samples_split is a fraction and ceil(min_samples_split * n_samples) are the minimum number of samples for each split.
min_samples_leafint or float, default=1
The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least min_samples_leaf training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression.
If int, then consider min_samples_leaf as the minimum number.
If float, then min_samples_leaf is a fraction and ceil(min_samples_leaf * n_samples) are the minimum number of samples for each node.
min_weight_fraction_leaffloat, default=0.0
The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided.
max_features{“sqrt”, “log2”, None}, int or float, default=”sqrt”
The number of features to consider when looking for the best split:
If int, then consider max_features features at each split.
If float, then max_features is a fraction and max(1, int(max_features * n_features_in_)) features are considered at each split.
If “auto”, then max_features=sqrt(n_features).
If “sqrt”, then max_features=sqrt(n_features).
If “log2”, then max_features=log2(n_features).
If None, then max_features=n_features.
Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than max_features features.
max_leaf_nodesint, default=None
Grow trees with max_leaf_nodes in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes.
min_impurity_decreasefloat, default=0.0
A node will be split if this split induces a decrease of the impurity greater than or equal to this value.
The weighted impurity decrease equation is the following:
N_t / N * (impurity - N_t_R / N_t * right_impurity
                    - N_t_L / N_t * left_impurity)
where N is the total number of samples, N_t is the number of samples at the current node, N_t_L is the number of samples in the left child, and N_t_R is the number of samples in the right child.
N, N_t, N_t_R and N_t_L all refer to the weighted sum, if sample_weight is passed.
bootstrapbool, default=True
Whether bootstrap samples are used when building trees. If False, the whole dataset is used to build each tree.
oob_scorebool, default=False
Whether to use out-of-bag samples to estimate the generalization score. Only available if bootstrap=True.
n_jobsint, default=None
The number of jobs to run in parallel. fit, predict, decision_path and apply are all parallelized over the trees. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See Glossary for more details.
random_stateint, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used when building trees (if bootstrap=True) and the sampling of the features to consider when looking for the best split at each node (if max_features < n_features). See Glossary for details.
verboseint, default=0
Controls the verbosity when fitting and predicting.
warm_startbool, default=False
When set to True, reuse the solution of the previous call to fit and add more estimators to the ensemble, otherwise, just fit a whole new forest. See the Glossary.
class_weight{“balanced”, “balanced_subsample”}, dict or list of dicts, default=None
Weights associated with classes in the form {class_label: weight}. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of y.
Note that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of [{1:1}, {2:5}, {3:1}, {4:1}].
The “balanced” mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as n_samples / (n_classes * np.bincount(y))
The “balanced_subsample” mode is the same as “balanced” except that weights are computed based on the bootstrap sample for every tree grown.
For multi-output, the weights of each column of y will be multiplied.
Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified.
ccp_alphanon-negative float, default=0.0
Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than ccp_alpha will be chosen. By default, no pruning is performed. See Minimal Cost-Complexity Pruning for details.
max_samplesint or float, default=None
If bootstrap is True, the number of samples to draw from X to train each base estimator.
If None (default), then draw X.shape[0] samples.
If int, then draw max_samples samples.
If float, then draw max_samples * X.shape[0] samples. Thus, max_samples should be in the interval (0.0, 1.0].










6. Evaluate the performance of the Model