diff --git a/generative-ai/prompts/AI-Tutor.md b/generative-ai/prompts/AI-Tutor.md new file mode 100644 index 0000000000..2a6420d505 --- /dev/null +++ b/generative-ai/prompts/AI-Tutor.md @@ -0,0 +1,261 @@ +# Design of AI Tutor Prompt + +We have designed an **AI Tutor** intended for educational scenarios, primarily aimed at providing guidance to students in various aspects of proactive learning. + +# Usage Scenarios + +We've divided the application of the AI tutor into two major use cases: + +### 1. Classroom Learning Scenario + +In this scenario, the **AI Tutor** assumes a role similar to a teacher: + +- **One-on-One Interaction**: It allows students to interact with the AI through a question-and-answer format. + +- **Directed Learning**: For instance, if a student is learning about the "Gradient Descent" algorithm, the AI will guide them through content related to gradient descent in machine learning, avoiding less relevant topics (such as linear regression). + +### 2. Course Project Scenario + +In this scenario, we expect the **AI Tutor** to guide students through completing a specific machine learning project: + +- **Environment Setup**: Guiding students on how to install relevant environments, for example, teaching them how to use and configure necessary Python libraries. + +- **Project Implementation**: Guiding students through the subtasks, like data processing, and informing them of feasible steps to complete the project, in a step-by-step manner. + +- **Multiple Dialogues**: Engaging in multiple interactions and dialogues with students, directing them through the completion of the entire project. + +We hope this AI can offer ample guidance and assistance to students on their learning journey. + + +# Fundamental Prompt + +### 1. **Start with a Warm Introduction:** +- Introduce yourself as an affable AI-Tutor, ready to facilitate the learning process. +``` +As you are an AI-tutor, remember that the student lack the specific information of the CONTEXT in the following conversation. Therefore, you should guide them and give them instructions to complete the TASK. +``` + +### 2. **Interactive Learning Process:** +- Inquire about the student’s interest topic, educational level, and pre-existing knowledge on the chosen topic. Utilize this data to customize explanations, examples, and analogies accordingly. +- Engage in an interactive dialog, promoting a student-centered learning environment by refraining from direct answers and instead encouraging self-derivation through guided questions and hints. +- Cheer on their advancements, and navigate through their struggles with supportive words and constructive feedback. +- Seek the student’s insights, invite them to elucidate their thoughts, and encourage them to explain concepts in their own words to validate understanding. +``` +===== RULES OF ROLES ===== + +``` + +### 3. **Task Prompt** +- Project and Assignment Guidance**: + - Lead them through project execution by providing step-by-step guidelines, ensuring they grasp both theoretical and practical aspects. + - Example: In a machine learning project, guide the student through the entire data science pipeline, from data collection and preprocessing to model training and evaluation. Provide support in coding and theory understanding. + +- Teaching Scenario: + - Ensure to embed theoretical teaching within the practical task where possible, making the learning applied and context-rich. + - Example: When guiding through a project related to Natural Language Processing (NLP), ensure to intertwine theoretical knowledge about tokenization, embedding, etc., with the practical steps of coding and implementation. Discuss why certain steps or methods are being used, and what alternative approaches might exist. +``` +===== TASK ===== + +``` + +### 4. **Contextual Relevance Prompt** +``` +===== CONTEXT CONTENT OF TASK ===== + +``` +- Why this prompt? + - Providing context enriches the learning experience and provides a framework where the knowledge can be applied, aiding in better retention and applicability of concepts. When students understand the “why” and “how” behind a concept or task, it not only enhances their conceptual understanding but also amplifies their ability to apply this knowledge innovatively in various scenarios. Furthermore, it anchors new information to existing knowledge, fostering a deeper understanding and improved recall. + - In educational settings, "Context" encapsulates the holistic environment and detailed framework within which teaching and learning occur. It involves not only the tangible content and instructional guides but also the subtle, intricately linked concepts, objectives, and real-world applications that enhance the educational experience. +- What content? + - Knowledge Points and Classroom Content: + Context here refers to the defined learning objectives, key concepts to be covered, and the structure of the teaching content. It also means creating a conducive learning environment where theoretical knowledge is seamlessly integrated with practical examples and real-world applications. + - Course Project Requirements and Details: + Context, in this case, provides a detailed roadmap and expectations about the course project, from the skills needed to the evaluation metrics. + +### 5. **Answer Template** +``` +===== ANSWER TEMPLATE ===== +AI-tutor: + +``` + +# Examples of Prompt and Chat History + +### 1. Original Prompt + +``` +As you are an AI-tutor, remember that the student lack the specific information of the CONTEXT in the following conversation. Therefore, you should guide them and give them instructions to complete the TASK. + +===== RULES OF ROLES ===== +You are an upbeat, encouraging tutor who helps students understand concepts by explaining ideas and asking students questions. Start by introducing yourself to the student as their AI-Tutor who is happy to help them with any questions. Only ask one question at a time. First, ask them what they would like to learn about. Wait for the response. Then ask them about their learning level: Are you a high school student, a college student or a professional? Wait for their response. Then ask them what they know already about the topic they have chosen. Wait for a response. Given this information, help students understand the topic by providing explanations, examples, analogies. These should be tailored to students learning level and prior knowledge or what they already know about the topic. + +Give students explanations, examples, and analogies about the concept to help them understand. You should guide students in an open-ended way. Do not provide immediate answers or solutions to problems but help students generate their own answers by asking leading questions. Ask students to explain their thinking. If the student is struggling or gets the answer wrong, try asking them to do part of the task or remind the student of their goal and give them a hint. If students improve, then praise them and show excitement. If the student struggles, then be encouraging and give them some ideas to think about. When pushing students for information, try to end your responses with a question so that students have to keep generating ideas. Once a student shows an appropriate level of understanding given their learning level, ask them to explain the concept in their own words; this is the best way to show you know something, or ask them for examples. When a student demonstrates that they know the concept you can move the conversation to a close and tell them you’re here to help if they have further questions. + +===== TASK ===== +{TASK} +===== CONTEXT CONTENT OF TASK ===== +Here is the CONTEXT of the TASK. You need to guide me complete the TASK in the specific CONTEXT. +{CONTEXT} + +===== ANSWER TEMPLATE ===== +AI-tutor: + +``` + +### 2. Classroom Learning Scenario + +- Example of Prompt + + ``` + As you are an AI-tutor, remember that the student lack the specific information of the CONTEXT in the following conversation. Therefore, you should guide them and give them instructions to complete the TASK. + + ===== RULES OF ROLES ===== + You are an upbeat, encouraging tutor who helps students understand concepts by explaining ideas and asking students questions. Start by introducing yourself to the student as their AI-Tutor who is happy to help them with any questions. Only ask one question at a time. First, ask them what they would like to learn about. Wait for the response. Then ask them about their learning level: Are you a high school student, a college student or a professional? Wait for their response. Then ask them what they know already about the topic they have chosen. Wait for a response. Given this information, help students understand the topic by providing explanations, examples, analogies. These should be tailored to students learning level and prior knowledge or what they already know about the topic. + + Give students explanations, examples, and analogies about the concept to help them understand. You should guide students in an open-ended way. Do not provide immediate answers or solutions to problems but help students generate their own answers by asking leading questions. Ask students to explain their thinking. If the student is struggling or gets the answer wrong, try asking them to do part of the task or remind the student of their goal and give them a hint. If students improve, then praise them and show excitement. If the student struggles, then be encouraging and give them some ideas to think about. When pushing students for information, try to end your responses with a question so that students have to keep generating ideas. Once a student shows an appropriate level of understanding given their learning level, ask them to explain the concept in their own words; this is the best way to show you know something, or ask them for examples. When a student demonstrates that they know the concept you can move the conversation to a close and tell them you’re here to help if they have further questions. + + ===== TASK ===== + Give instructions to teach students the knowledge contained in CONTEXT. + + ===== CONTEXT CONTENT OF TASK ===== + Here is the CONTEXT of the TASK. You need to guide me complete the TASK in the specific CONTEXT. + `` + **Understanding Gradient Descent in Machine Learning** + In the extensive and captivating realm of Machine Learning (ML), one of the pivotal concepts that garners substantial attention is "Gradient Descent." This algorithm plays a vital role in optimizing various models by minimizing a function, often representing a cost or loss, which quantifies how well the model predicts the target variable. + + **Conceptual Overview:** + Gradient Descent is a first-order iterative optimization algorithm for finding the minimum of a function. In the context of ML, this function is the Loss Function, which measures the discrepancy between the actual output and the output predicted by the model. To minimize this discrepancy, the model's parameters are iteratively adjusted. + + **Key Components:** + 1. **Loss Function:** A metric that quantifies the error between predicted and actual output. Common examples include Mean Squared Error for regression and Cross-Entropy Loss for classification. + 2. **Gradient:** The gradient of a function at a particular point refers to the rate at which the function changes if the input is modified slightly. Mathematically, it's a partial derivative with respect to its parameters. + 3. **Learning Rate:** A hyperparameter that determines the size of the step that we take while moving towards the minimum. A too-small learning rate may lead to slow convergence, while a too-large one may cause the algorithm to overshoot the minimum. + + **The Algorithm:** + The Gradient Descent algorithm iteratively tweaks the model parameters to minimize the loss function. Here is a simplified step-by-step process: + + - Initialize model parameters randomly. + - Calculate the gradient of the loss function with respect to each parameter. + - Update the parameters in the opposite direction of the gradient: `new_param = old_param - learning_rate * gradient` + - Repeat until the gradient is close to zero or a predetermined number of iterations is reached. + + **Types of Gradient Descent:** + 1. **Batch Gradient Descent:** Computes the gradient using the entire dataset. While precise, it can be computationally intensive for large datasets. + 2. **Stochastic Gradient Descent (SGD):** Computes the gradient using a single data point chosen at random, which can be faster but tends to introduce noise into the convergence process. + 3. **Mini-Batch Gradient Descent:** A compromise between Batch and SGD, it uses a random subset of data to compute the gradient, balancing computational efficiency and convergence stability. + + **Practical Implications:** + Understanding and efficiently implementing Gradient Descent is pivotal in optimizing ML models, especially in scenarios involving vast and complex datasets. While its concept may seem straightforward, its application involves dealing with challenges like choosing an apt learning rate, avoiding local minima, and ensuring computational efficiency. + + It’s noteworthy that while the essence of Gradient Descent remains constant, its application might diverge into numerous variants, each suited to particular types of problems and data characteristics in the practical and ever-expanding world of Machine Learning. + `` + + ===== ANSWER TEMPLATE ===== + AI-tutor: + + ``` + +- Demo + + [Chat History: AI-Tutor-Teaching](https://chat.openai.com/share/4246ef3c-bb5e-4e0b-b8a8-281f9377ff67) + + +### 3. Course Project Scenario + +- Example of Prompt + + ``` + As you are an AI- tutor, remember that the student lack the specific information of the CONTEXT in the following conversation. Therefore, you should guide them and give them instructions to complete the TASK. + + ===== Rules of Roles ===== + You are an upbeat, encouraging tutor who helps students understand concepts by explaining ideas and asking students questions. Start by introducing yourself to the student as their AI-Tutor who is happy to help them with any questions. Only ask one question at a time. First, ask them what they would like to learn about. Wait for the response. Then ask them about their learning level: Are you a high school student, a college student or a professional? Wait for their response. Then ask them what they know already about the topic they have chosen. Wait for a response. Given this information, help students understand the topic by providing explanations, examples, analogies. These should be tailored to students learning level and prior knowledge or what they already know about the topic. + + Give students explanations, examples, and analogies about the concept to help them understand. You should guide students in an open-ended way. Do not provide immediate answers or solutions to problems but help students generate their own answers by asking leading questions. Ask students to explain their thinking. If the student is struggling or gets the answer wrong, try asking them to do part of the task or remind the student of their goal and give them a hint. If students improve, then praise them and show excitement. If the student struggles, then be encouraging and give them some ideas to think about. When pushing students for information, try to end your responses with a question so that students have to keep generating ideas. Once a student shows an appropriate level of understanding given their learning level, ask them to explain the concept in their own words; this is the best way to show you know something, or ask them for examples. When a student demonstrates that they know the concept you can move the conversation to a close and tell them you’re here to help if they have further questions. + + ===== TASK ===== + Assist me to develop a machine learning model to classify images of fruits into predefined categories. + + ===== CONTEXT CONTENT OF TASK ===== + Here is the CONTEXT of the TASK. You need to guide me complete the TASK in the specific CONTEXT. + `` + **Project Name**: FruitImageClassifier + + **Project Description**: + ### 1. Environment Setup + #### 1.1 Hardware Requirements + - **GPU**: NVIDIA GTX 1080 Ti or equivalent for model training. + - **CPU**: Intel i7 or equivalent. + - **RAM**: Minimum of 16GB. + + #### 1.2 Software Requirements + - **Operating System**: Ubuntu 20.04 LTS. + - **Programming Language**: Python 3.8. + + ### 2. Dependencies Installation + Ensure you have `pip` installed. Then, use it to install the following dependencies: + ``bash + pip install tensorflow==2.6 scikit-learn==0.24 numpy==1.19 pandas==1.2 matplotlib==3.4 + `` + + ### 3. Configuration Files + #### 3.1 Dataset Configuration (`data_config.json`) + ``json + { + "train_data_path": "./data/train", + "test_data_path": "./data/test", + "validation_split": 0.2, + "batch_size": 32, + "image_size": [224, 224], + "num_classes": 5 + } + `` + #### 3.2 Model Configuration (`model_config.json`) + ``json + { + "base_model": "MobileNetV2", + "base_model_weights": "imagenet", + "learning_rate": 0.0001, + "epochs": 20, + "checkpoint_path": "./checkpoints" + } + `` + + ### 4. Model Training Script (`train_model.py`) + Ensure the following structure is followed in your training script to utilize the configuration files effectively: + ``python + import json + import tensorflow as tf + from sklearn.model_selection import train_test_split + # Other necessary imports... + + # Load configurations + with open('data_config.json', 'r') as file: + data_config = json.load(file) + with open('model_config.json', 'r') as file: + model_config = json.load(file) + + # Implement your data loading, pre-processing, and model training... + `` + + ### 5. Model Deployment + - **Local Deployment**: Utilize TensorFlow Serving or a Flask API for local testing. + - **Cloud Deployment**: Consider options such as AWS SageMaker, Google AI Platform, or Azure ML for scalable deployment. + + ### 6. Monitoring and Logging + - Ensure continuous monitoring of the model's performance metrics. + - Set up logging to keep track of requests and potential issues during the inference phase. + + ### 7. Model Maintenance + - Regularly evaluate model performance. + - Update the dataset and retrain the model as needed. + - Ensure that system dependencies are updated and tested for compatibility. + `` + + ===== ANSWER TEMPLATE ===== + AI-tutor: + + ``` + +- Demo + + [Chat History: AI-Tutor-Project](https://chat.openai.com/share/6c31ac3c-8ff2-4216-a438-8dfed4d5f4ba) diff --git a/open-machine-learning-jupyter-book/_config.yml b/open-machine-learning-jupyter-book/_config.yml index 9a3f6ad43c..703375180b 100644 --- a/open-machine-learning-jupyter-book/_config.yml +++ b/open-machine-learning-jupyter-book/_config.yml @@ -25,6 +25,8 @@ execute: - 'ml-advanced/clustering/k-means-clustering.ipynb' - 'data-science/data-visualization/visualization-distributions.md' - 'ml-advanced/unsupervised-learning.ipynb' + - 'data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.ipynb' + - 'data-science/data-science-in-the-cloud/the-low-code-no-code-way.ipynb' parse: myst_enable_extensions: diff --git a/open-machine-learning-jupyter-book/_toc.yml b/open-machine-learning-jupyter-book/_toc.yml index f72fd9f83f..5923dcc0aa 100644 --- a/open-machine-learning-jupyter-book/_toc.yml +++ b/open-machine-learning-jupyter-book/_toc.yml @@ -52,7 +52,6 @@ parts: - file: ml-fundamentals/regression/tools-of-the-trade - file: ml-fundamentals/regression/managing-data - file: ml-fundamentals/regression/linear-and-polynomial-regression - - file: ml-fundamentals/regression/loss-function - file: ml-fundamentals/regression/logistic-regression - file: ml-fundamentals/build-a-web-app-to-use-a-machine-learning-model - file: ml-fundamentals/classification/getting-started-with-classification @@ -152,6 +151,7 @@ parts: - file: assignments/ml-fundamentals/ml-linear-regression-1 - file: assignments/ml-fundamentals/ml-linear-regression-2 - file: assignments/ml-fundamentals/ml-logistic-regression-1 + - file: assignments/ml-fundamentals/ml-logistic-regression-2 - file: assignments/ml-fundamentals/ml-neural-network-1 # - file: assignments/ml-fundamentals/build-an-ml-web-app-1 # - file: assignments/ml-fundamentals/build-an-ml-web-app-2 @@ -223,6 +223,7 @@ parts: - file: slides/ml-fundamentals/ml-overview - file: slides/ml-fundamentals/linear-regression - file: slides/ml-fundamentals/logistic-regression + - file: slides/ml-fundamentals/logistic-regression-condensed - file: slides/ml-fundamentals/neural-network - file: slides/ml-fundamentals/build-an-ml-web-app - file: slides/ml-advanced/unsupervised-learning diff --git a/open-machine-learning-jupyter-book/assignments/ml-advanced/unsupervised-learning/k-means-clustering-with-python.ipynb b/open-machine-learning-jupyter-book/assignments/ml-advanced/unsupervised-learning/k-means-clustering-with-python.ipynb new file mode 100644 index 0000000000..8214d66d3b --- /dev/null +++ b/open-machine-learning-jupyter-book/assignments/ml-advanced/unsupervised-learning/k-means-clustering-with-python.ipynb @@ -0,0 +1 @@ +{"cells":[{"cell_type":"markdown","metadata":{},"source":["\n","# K-Means Clustering with Python\n"]},{"cell_type":"markdown","metadata":{},"source":["K-Means clustering is the most popular unsupervised machine learning algorithm. K-Means clustering is used to find intrinsic groups within the unlabelled dataset and draw inferences from them. In this kernel, I implement K-Means clustering to find intrinsic groups within the dataset that display the same `status_type` behaviour. The `status_type` behaviour variable consists of posts of a different nature (video, photos, statuses and links).\n","\n","\n","So, let's get started."]},{"cell_type":"markdown","metadata":{},"source":["## Introduction to K-Means Clustering\n","\n","\n","Machine learning algorithms can be broadly classified into two categories - supervised and unsupervised learning. There are other categories also like semi-supervised learning and reinforcement learning. But, most of the algorithms are classified as supervised or unsupervised learning. The difference between them happens because of presence of target variable. In unsupervised learning, there is no target variable. The dataset only has input variables which describe the data. This is called unsupervised learning.\n","\n","K-Means clustering is the most popular unsupervised learning algorithm. It is used when we have unlabelled data which is data without defined categories or groups. The algorithm follows an easy or simple way to classify a given data set through a certain number of clusters, fixed apriori. K-Means algorithm works iteratively to assign each data point to one of K groups based on the features that are provided. Data points are clustered based on feature similarity.\n"]},{"cell_type":"markdown","metadata":{},"source":["## K-Means\n","\n","![K-Means](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-advanced/k-means/k-means-visualization.png)"]},{"cell_type":"markdown","metadata":{},"source":["## K-Means Clustering intuition\n","\n","\n","K-Means clustering is used to find intrinsic groups within the unlabelled dataset and draw inferences from them. It is based on centroid-based clustering.\n","\n","\n","Centroid - A centroid is a data point at the centre of a cluster. In centroid-based clustering, clusters are represented by a centroid. It is an iterative algorithm in which the notion of similarity is derived by how close a data point is to the centroid of the cluster.\n","K-Means clustering works as follows:-\n","The K-Means clustering algorithm uses an iterative procedure to deliver a final result. The algorithm requires number of clusters K and the data set as input. The data set is a collection of features for each data point. The algorithm starts with initial estimates for the K centroids. The algorithm then iterates between two steps:-\n","\n","\n","## Data assignment step\n","\n","\n","Each centroid defines one of the clusters. In this step, each data point is assigned to its nearest centroid, which is based on the squared Euclidean distance. So, if ci is the collection of centroids in set C, then each data point is assigned to a cluster based on minimum Euclidean distance. \n","\n","\n","\n","## Centroid update step\n","\n","\n","In this step, the centroids are recomputed and updated. This is done by taking the mean of all data points assigned to that centroid’s cluster. \n","\n","\n","The algorithm then iterates between step 1 and step 2 until a stopping criteria is met. Stopping criteria means no data points change the clusters, the sum of the distances is minimized or some maximum number of iterations is reached.\n","This algorithm is guaranteed to converge to a result. The result may be a local optimum meaning that assessing more than one run of the algorithm with randomized starting centroids may give a better outcome.\n","\n","The K-Means intuition can be represented with the help of following diagram:-\n"]},{"cell_type":"markdown","metadata":{},"source":["## K-Means intuition\n","![K-Means intuition](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-advanced/k-means/k-means-clustering-example.jpg)"]},{"cell_type":"markdown","metadata":{},"source":["## Choosing the value of K\n","\n","\n","The K-Means algorithm depends upon finding the number of clusters and data labels for a pre-defined value of K. To find the number of clusters in the data, we need to run the K-Means clustering algorithm for different values of K and compare the results. So, the performance of K-Means algorithm depends upon the value of K. We should choose the optimal value of K that gives us best performance. There are different techniques available to find the optimal value of K. The most common technique is the elbow method which is described below.\n"]},{"cell_type":"markdown","metadata":{},"source":["## The elbow method\n","\n","\n","The elbow method is used to determine the optimal number of clusters in K-means clustering. The elbow method plots the value of the cost function produced by different values of K. "]},{"cell_type":"markdown","metadata":{},"source":["## Import libraries\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# This Python 3 environment comes with many helpful analytics libraries installed\n","# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n","# For example, here's several helpful packages to load in \n","\n","import numpy as np # linear algebra\n","import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n","import matplotlib.pyplot as plt # for data visualization\n","import seaborn as sns # for statistical data visualization\n","%matplotlib inline\n","\n","# Input data files are available in the \"../input/\" directory.\n","# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n","\n","import os\n","for dirname, _, filenames in os.walk('/kaggle/input'):\n"," for filename in filenames:\n"," print(os.path.join(dirname, filename))\n","\n","# Any results you write to the current directory are saved as output.\n"]},{"cell_type":"markdown","metadata":{},"source":["### Ignore warnings\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["import warnings\n","\n","warnings.filterwarnings('ignore')"]},{"cell_type":"markdown","metadata":{},"source":["## Import dataset\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["data = 'https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/Live.csv'\n","\n","df = pd.read_csv(data)\n"]},{"cell_type":"markdown","metadata":{},"source":["## Exploratory data analysis\n"]},{"cell_type":"markdown","metadata":{},"source":["### Check shape of the dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.shape"]},{"cell_type":"markdown","metadata":{},"source":["We can see that there are 7050 instances and 16 attributes in the dataset. In the dataset description, it is given that there are 7051 instances and 12 attributes in the dataset.\n","\n","So, we can infer that the first instance is the row header and there are 4 extra attributes in the dataset. Next, we should take a look at the dataset to gain more insight about it."]},{"cell_type":"markdown","metadata":{},"source":["### Preview the dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.head()"]},{"cell_type":"markdown","metadata":{},"source":["### View summary of dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.info()"]},{"cell_type":"markdown","metadata":{},"source":["### Check for missing values in dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.isnull().sum()"]},{"cell_type":"markdown","metadata":{},"source":["We can see that there are 4 redundant columns in the dataset. We should drop them before proceeding further."]},{"cell_type":"markdown","metadata":{},"source":["### Drop redundant columns"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.drop(['Column1', 'Column2', 'Column3', 'Column4'], axis=1, inplace=True)"]},{"cell_type":"markdown","metadata":{},"source":["### Again view summary of dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.info()"]},{"cell_type":"markdown","metadata":{},"source":["Now, we can see that redundant columns have been removed from the dataset. \n","\n","We can see that, there are 3 character variables (data type = object) and remaining 9 numerical variables (data type = int64).\n"]},{"cell_type":"markdown","metadata":{},"source":["### View the statistical summary of numerical variables"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.describe()"]},{"cell_type":"markdown","metadata":{},"source":["There are 3 categorical variables in the dataset. I will explore them one by one."]},{"cell_type":"markdown","metadata":{},"source":["### Explore `status_id` variable"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view the labels in the variable\n","\n","df['status_id'].unique()"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view how many different types of variables are there\n","\n","len(df['status_id'].unique())"]},{"cell_type":"markdown","metadata":{},"source":["We can see that there are 6997 unique labels in the `status_id` variable. The total number of instances in the dataset is 7050. So, it is approximately a unique identifier for each of the instances. Thus this is not a variable that we can use. Hence, I will drop it."]},{"cell_type":"markdown","metadata":{},"source":["### Explore `status_published` variable"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view the labels in the variable\n","\n","df['status_published'].unique()"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view how many different types of variables are there\n","\n","len(df['status_published'].unique())"]},{"cell_type":"markdown","metadata":{},"source":["Again, we can see that there are 6913 unique labels in the `status_published` variable. The total number of instances in the dataset is 7050. So, it is also a approximately a unique identifier for each of the instances. Thus this is not a variable that we can use. Hence, I will drop it also."]},{"cell_type":"markdown","metadata":{},"source":["### Explore `status_type` variable"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view the labels in the variable\n","\n","df['status_type'].unique()"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["# view how many different types of variables are there\n","\n","len(df['status_type'].unique())"]},{"cell_type":"markdown","metadata":{},"source":["We can see that there are 4 categories of labels in the `status_type` variable."]},{"cell_type":"markdown","metadata":{},"source":["### Drop `status_id` and `status_published` variable from the dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.drop(['status_id', 'status_published'], axis=1, inplace=True)"]},{"cell_type":"markdown","metadata":{},"source":["### View the summary of dataset again"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.info()"]},{"cell_type":"markdown","metadata":{},"source":["### Preview the dataset again"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["df.head()"]},{"cell_type":"markdown","metadata":{},"source":["We can see that there is 1 non-numeric column `status_type` in the dataset. I will convert it into integer equivalents."]},{"cell_type":"markdown","metadata":{},"source":["## Declare feature vector and target variable\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["X = df\n","\n","y = df['status_type']"]},{"cell_type":"markdown","metadata":{},"source":["## Convert categorical variable into integers\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["from sklearn.preprocessing import LabelEncoder\n","\n","le = LabelEncoder()\n","\n","X['status_type'] = le.fit_transform(X['status_type'])\n","\n","y = le.transform(y)"]},{"cell_type":"markdown","metadata":{},"source":["### View the summary of X"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["X.info()"]},{"cell_type":"markdown","metadata":{},"source":["### Preview the dataset X"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["X.head()"]},{"cell_type":"markdown","metadata":{},"source":["## Feature Scaling"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["cols = X.columns"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["from sklearn.preprocessing import MinMaxScaler\n","\n","ms = MinMaxScaler()\n","\n","X = ms.fit_transform(X)"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["X = pd.DataFrame(X, columns=[cols])"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["X.head()"]},{"cell_type":"markdown","metadata":{},"source":["## K-Means model with two clusters"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["from sklearn.cluster import KMeans\n","\n","kmeans = KMeans(n_clusters=2, random_state=0) \n","\n","kmeans.fit(X)"]},{"cell_type":"markdown","metadata":{},"source":["## K-Means model parameters study"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["kmeans.cluster_centers_"]},{"cell_type":"markdown","metadata":{},"source":["- The KMeans algorithm clusters data by trying to separate samples in n groups of equal variances, minimizing a criterion known as `inertia`, or within-cluster sum-of-squares Inertia, or the within-cluster sum of squares criterion, can be recognized as a measure of how internally coherent clusters are.\n","\n","\n","- The k-means algorithm divides a set of N samples X into K disjoint clusters C, each described by the mean j of the samples in the cluster. The means are commonly called the cluster centroids.\n","\n","\n","- The K-means algorithm aims to choose centroids that minimize the inertia, or within-cluster sum of squared criterion."]},{"cell_type":"markdown","metadata":{},"source":["### Inertia\n","\n","\n","- `Inertia` is not a normalized metric. \n","\n","- The lower values of inertia are better and zero is optimal. \n","\n","- But in very high-dimensional spaces, euclidean distances tend to become inflated (this is an instance of `curse of dimensionality`). \n","\n","- Running a dimensionality reduction algorithm such as PCA prior to k-means clustering can alleviate this problem and speed up the computations.\n","\n","- We can calculate model inertia as follows:-"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["kmeans.inertia_"]},{"cell_type":"markdown","metadata":{},"source":["- The lesser the model inertia, the better the model fit.\n","\n","- We can see that the model has very high inertia. So, this is not a good model fit to the data."]},{"cell_type":"markdown","metadata":{},"source":[" ## Check quality of weak classification by the model"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["labels = kmeans.labels_\n","\n","# check how many of the samples were correctly labeled\n","correct_labels = sum(y == labels)\n","\n","print(\"Result: %d out of %d samples were correctly labeled.\" % (correct_labels, y.size))\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))"]},{"cell_type":"markdown","metadata":{},"source":["We have achieved a weak classification accuracy of 1% by our unsupervised model."]},{"cell_type":"markdown","metadata":{},"source":["## Use elbow method to find optimal number of clusters\n"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["from sklearn.cluster import KMeans\n","cs = []\n","for i in range(1, 11):\n"," kmeans = KMeans(n_clusters = i, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0)\n"," kmeans.fit(X)\n"," cs.append(kmeans.inertia_)\n","plt.plot(range(1, 11), cs)\n","plt.title('The Elbow Method')\n","plt.xlabel('Number of clusters')\n","plt.ylabel('CS')\n","plt.show()\n"]},{"cell_type":"markdown","metadata":{},"source":["- By the above plot, we can see that there is a kink at k=2. \n","\n","- Hence k=2 can be considered a good number of the cluster to cluster this data.\n","\n","- But, we have seen that I have achieved a weak classification accuracy of 1% with k=2.\n","\n","- I will write the required code with k=2 again for convinience."]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["from sklearn.cluster import KMeans\n","\n","kmeans = KMeans(n_clusters=2,random_state=0)\n","\n","kmeans.fit(X)\n","\n","labels = kmeans.labels_\n","\n","# check how many of the samples were correctly labeled\n","\n","correct_labels = sum(y == labels)\n","\n","print(\"Result: %d out of %d samples were correctly labeled.\" % (correct_labels, y.size))\n","\n","print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))"]},{"cell_type":"markdown","metadata":{},"source":["So, our weak unsupervised classification model achieved a very weak classification accuracy of 1%."]},{"cell_type":"markdown","metadata":{},"source":["I will check the model accuracy with different number of clusters."]},{"cell_type":"markdown","metadata":{},"source":["## K-Means model with different clusters"]},{"cell_type":"markdown","metadata":{},"source":["### K-Means model with 3 clusters"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["kmeans = KMeans(n_clusters=3, random_state=0)\n","\n","kmeans.fit(X)\n","\n","# check how many of the samples were correctly labeled\n","labels = kmeans.labels_\n","\n","correct_labels = sum(y == labels)\n","print(\"Result: %d out of %d samples were correctly labeled.\" % (correct_labels, y.size))\n","print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))"]},{"cell_type":"markdown","metadata":{},"source":["### K-Means model with 4 clusters"]},{"cell_type":"code","execution_count":null,"metadata":{"trusted":true},"outputs":[],"source":["kmeans = KMeans(n_clusters=4, random_state=0)\n","\n","kmeans.fit(X)\n","\n","# check how many of the samples were correctly labeled\n","labels = kmeans.labels_\n","\n","correct_labels = sum(y == labels)\n","print(\"Result: %d out of %d samples were correctly labeled.\" % (correct_labels, y.size))\n","print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))"]},{"cell_type":"markdown","metadata":{},"source":["We have achieved a relatively high accuracy of 62% with k=4."]},{"cell_type":"markdown","metadata":{},"source":["## Results and conclusion\n","\n","\n","In this project, I have implemented the most popular unsupervised clustering technique called K-Means Clustering.\n","\n","I have applied the elbow method and find that k=2 (k is number of clusters) can be considered a good number of cluster to cluster this data.\n","\n","I have find that the model has very high inertia of 237.7572. So, this is not a good model fit to the data.\n","\n","I have achieved a weak classification accuracy of 1% with k=2 by our unsupervised model.\n","\n","So, I have changed the value of k and find relatively higher classification accuracy of 62% with k=4.\n","\n","Hence, we can conclude that k=4 being the optimal number of clusters.\n"]},{"cell_type":"markdown","metadata":{},"source":["## Acknowledgments\n","Thanks to Gokulprasanth T for creating the open-source project [K-Means Clustering with Python](https://www.kaggle.com/code/prashant111/k-means-clustering-with-python), lisensed under the [Prashant Banerjee](https://www.kaggle.com/prashant111). It inspires the majority of the content in this chapter."]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"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.8.17"}},"nbformat":4,"nbformat_minor":4} diff --git a/open-machine-learning-jupyter-book/assignments/ml-fundamentals/ml-logistic-regression-2.ipynb b/open-machine-learning-jupyter-book/assignments/ml-fundamentals/ml-logistic-regression-2.ipynb new file mode 100644 index 0000000000..a6344b19d2 --- /dev/null +++ b/open-machine-learning-jupyter-book/assignments/ml-fundamentals/ml-logistic-regression-2.ipynb @@ -0,0 +1,88 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ML logistic regression - assignment 2\n", + "\n", + "## Logistic Regression from scratch" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "class MyOwnLogisticRegression:\n", + " def __init__(self, learning_rate=0.001, n_iters=1000):\n", + " self.lr = learning_rate\n", + " self.n_iters = n_iters\n", + " self.weights = None\n", + " self.bias = None\n", + "\n", + " def fit(self, X, y):\n", + " n_samples, n_features = X.shape\n", + "\n", + " # init parameters\n", + " self.weights = np.zeros(n_features)\n", + " self.bias = 0\n", + "\n", + " # gradient descent\n", + " for _ in range(self.n_iters):\n", + " # approximate y with linear combination of weights and x, plus bias\n", + " linear_model = np.dot(X, self.weights) + self.bias\n", + " # apply sigmoid function\n", + " y_predicted = self._sigmoid(linear_model)\n", + "\n", + " # compute gradients\n", + " dw = (1 / n_samples) * np.dot(X.T, (y_predicted - y))\n", + " db = (1 / n_samples) * np.sum(y_predicted - y)\n", + " # update parameters\n", + " self.weights -= self.lr * dw\n", + " self.bias -= self.lr * db\n", + "\n", + " def predict(self, X):\n", + " linear_model = np.dot(X, self.weights) + self.bias\n", + " y_predicted = self._sigmoid(linear_model)\n", + " y_predicted_cls = [1 if i > 0.5 else 0 for i in y_predicted]\n", + " return np.array(y_predicted_cls)\n", + "\n", + " def _sigmoid(self, x):\n", + " return 1 / (1 + np.exp(-x))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.16" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.ipynb b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.ipynb new file mode 100644 index 0000000000..dd6cac58e6 --- /dev/null +++ b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.ipynb @@ -0,0 +1,81 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "33887561-a556-495e-8744-a192d65a947d", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "53182f7d-455f-4fd6-b9e8-75bbe9d32ed0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" + ] + }, + { + "cell_type": "markdown", + "id": "d51de614", + "metadata": {}, + "source": [ + "# Data Science in the cloud\n", + "\n", + "![cloud-picture](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/cloud-picture.jpeg)\n", + "\n", + "> Photo by [Jelleke Vanooteghem](https://unsplash.com/@ilumire) from [Unsplash](https://unsplash.com/s/photos/cloud?orientation=landscape)\n", + "\n", + "When it comes to doing data science with big data, the cloud can be a game changer. In the next three sections, we are going to see what the cloud is and why it can be very helpful. We are also going to explore a heart failure dataset and build a model to help assess the probability of someone having heart failure. We will use the power of the cloud to train, deploy and consume a model in two different ways. One way uses only the user interface in a Low code/No code fashion, and the other way uses the Azure Machine Learning Software Developer Kit (Azure ML SDK).\n", + "\n", + "![project-schema](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/project-schema.png)\n", + "\n", + "---\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.md b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.md deleted file mode 100644 index 428ba3e91a..0000000000 --- a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/data-science-in-the-cloud.md +++ /dev/null @@ -1,29 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Data Science in the cloud - -![cloud-picture](../../../images/cloud-picture.jpeg) - -> Photo by [Jelleke Vanooteghem](https://unsplash.com/@ilumire) from [Unsplash](https://unsplash.com/s/photos/cloud?orientation=landscape) - -When it comes to doing data science with big data, the cloud can be a game changer. In the next three sections, we are going to see what the cloud is and why it can be very helpful. We are also going to explore a heart failure dataset and build a model to help assess the probability of someone having heart failure. We will use the power of the cloud to train, deploy and consume a model in two different ways. One way uses only the user interface in a Low code/No code fashion, and the other way uses the Azure Machine Learning Software Developer Kit (Azure ML SDK). - -![project-schema](../../../images/project-schema.png) - ---- - -```{tableofcontents} -``` diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.ipynb b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.ipynb new file mode 100644 index 0000000000..35ae0af251 --- /dev/null +++ b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.ipynb @@ -0,0 +1,165 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7e3566be-b99b-41c1-baa4-a5605e5a9896", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "99bdfaf7-62b7-4a12-8312-6ab34a7bb7e1", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" + ] + }, + { + "cell_type": "markdown", + "id": "6e3ccba0-778b-4fc0-9093-437024a2bda4", + "metadata": { + "tags": [] + }, + "source": [ + "# Introduction\n", + "\n", + "In this section, you will learn the fundamental principles of the cloud, then you will see why it can be interesting for you to use cloud services to run your data science projects and we'll look at some examples of data science projects run in the cloud.\n", + "\n", + "## What is the cloud?\n", + "\n", + "The Cloud, or Cloud Computing, is the delivery of a wide range of pay-as-you-go computing services hosted on infrastructure over the internet. Services include solutions such as storage, databases, networking, software, analytics, and intelligent services.\n", + "\n", + "We usually differentiate the Public, Private and Hybrid clouds as follows:\n", + "\n", + "* Public cloud: a public cloud is owned and operated by a third-party cloud service provider which delivers its computing resources over the Internet to the public.\n", + "* Private cloud: refers to cloud computing resources used exclusively by a single business or organization, with services and infrastructure maintained on a private network.\n", + "* Hybrid cloud: the hybrid cloud is a system that combines public and private clouds. Users opt for an on-premises data center while allowing data and applications to be run on one or more public clouds.\n", + "\n", + "Most cloud computing services fall into three categories: Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS).\n", + "\n", + "* Infrastructure as a Service (IaaS): users rent an IT infrastructure such as servers and virtual machines (VMs), storage, networks, operating systems\n", + "* Platform as a Service (PaaS): users rent an environment for developing, testing, delivering, and managing software applications. Users don't need to worry about setting up or managing the underlying infrastructure of servers, storage, network, and databases needed for development.\n", + "* Software as a Service (SaaS): users get access to software applications over the Internet, on-demand and typically on a subscription basis. Users don't need to worry about hosting and managing the software application, the underlying infrastructure or the maintenance, like software upgrades and security patching.\n", + "\n", + "Some of the largest Cloud providers are Amazon Web Services, Google Cloud Platform and Microsoft Azure.\n", + "\n", + "## Why choose the cloud for Data Science?\n", + "\n", + "Developers and IT professionals chose to work with the Cloud for many reasons, including the following:\n", + "\n", + "* Innovation: you can power your applications by integrating innovative services created by Cloud providers directly into your apps.\n", + "* Flexibility: you only pay for the services that you need and can choose from a wide range of services. You typically pay as you go and adapt your services according to your evolving needs.\n", + "* Budget: you don't need to make initial investments to purchase hardware and software, set up and run on-site data centers and you can just pay for what you use.\n", + "* Scalability: your resources can scale according to the needs of your project, which means that your apps can use more or less computing power, storage and bandwidth, by adapting to external factors at any given time.\n", + "* Productivity: you can focus on your business rather than spending time on tasks that can be managed by someone else, such as managing data centers.\n", + "* Reliability: Cloud Computing offers several ways to continuously back up your data and you can set up disaster recovery plans to keep your business and services going, even in times of crisis.\n", + "* Security: you can benefit from policies, technologies and controls that strengthen the security of your project.\n", + "\n", + "These are some of the most common reasons why people choose to use Cloud services. Now that we have a better understanding of what the Cloud is and what its main benefits are, let's look more specifically into the jobs of Data scientists and developers working with data, and how the Cloud can help them with several challenges they might face:\n", + "\n", + "* Storing large amounts of data: instead of buying, managing and protecting big servers, you can store your data directly in the cloud, with solutions such as Azure Cosmos DB, Azure SQL Database and Azure Data Lake Storage.\n", + "* Performing Data Integration: data integration is an essential part of Data Science, that lets you make a transition from data collection to taking action. With data integration services offered in the cloud, you can collect, transform and integrate data from various sources into a single data warehouse, with Data Factory.\n", + "* Processing data: processing vast amounts of data requires a lot of computing power, and not everyone has access to machines powerful enough for that, which is why many people choose to directly harness the cloud's huge computing power to run and deploy their solutions.\n", + "* Using data analytics services: cloud services like Azure Synapse Analytics, Azure Stream Analytics and Azure Databricks to help you turn your data into actionable insights.\n", + "* Using Machine Learning and data intelligence services: Instead of starting from scratch, you can use machine learning algorithms offered by the cloud provider, with services such as AzureML. You can also use cognitive services such as speech-to-text, text-to-speech, computer vision and more.\n", + "\n", + "## Examples of Data Science in the cloud\n", + "\n", + "Let's make this more tangible by looking at a couple of scenarios.\n", + "\n", + "### Real-time social media sentiment analysis\n", + "\n", + "We'll start with a scenario commonly studied by people who start with machine learning: social media sentiment analysis in real time.\n", + "\n", + "Let's say you run a news media website and you want to leverage live data to understand what content your readers could be interested in. To know more about that, you can build a program that performs real-time sentiment analysis of data from Twitter publications, on topics that are relevant to your readers.\n", + "\n", + "The key indicators you will look at are the volume of tweets on specific topics (hashtags) and sentiment, which is established using analytics tools that perform sentiment analysis around the specified topics.\n", + "\n", + "The steps necessary to create this project are as follows:\n", + "\n", + "* Create an event hub for streaming input, which will collect data from Twitter.\n", + "* Configure and start a Twitter client application, which will call the Twitter Streaming APIs.\n", + "* Create a Stream Analytics job.\n", + "* Specify the job input and query.\n", + "* Create an output sink and specify the job output.\n", + "* Start the job.\n", + "\n", + "To view the full process, check out the [documentation](https://docs.microsoft.com/azure/stream-analytics/stream-analytics-twitter-sentiment-analysis-trends?WT.mc_id=academic-77958-bethanycheum&ocid=AID30411099).\n", + "\n", + "### Scientific papers analysis\n", + "\n", + "Let's take another example of a project created by [Dmitry Soshnikov](http://soshnikov.com), one of the authors of this curriculum.\n", + "\n", + "Dmitry created a tool that analyses COVID papers. By reviewing this project, you will see how you can create a tool that extracts knowledge from scientific papers, gains insights and helps researchers navigate through large collections of papers in an efficient way.\n", + "\n", + "Let's see the different steps used for this:\n", + "\n", + "* Extracting and pre-processing information with [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109).\n", + "* Using [Azure ML](https://azure.microsoft.com/services/machine-learning?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) to parallelize the processing.\n", + "* Storing and querying information with [Cosmos DB](https://azure.microsoft.com/services/cosmos-db?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109).\n", + "* Create an interactive dashboard for data exploration and visualization using Power BI.\n", + "\n", + "To see the full process, visit [Dmitry's blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/).\n", + "\n", + "As you can see, we can leverage Cloud services in many ways to perform Data Science.\n", + "\n", + "## Self study\n", + "\n", + "* [What Is Cloud Computing? A Beginner's Guide | Microsoft Azure](https://azure.microsoft.com/overview/what-is-cloud-computing?ocid=AID3041109)\n", + "* [Social media analysis with Azure Stream Analytics | Microsoft Learn](https://docs.microsoft.com/azure/stream-analytics/stream-analytics-twitter-sentiment-analysis-trends?ocid=AID3041109)\n", + "* [Analyzing COVID Medical Papers with Azure and Text Analytics for Health](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/)\n", + "\n", + "## Your turn! 🚀\n", + "\n", + "[Market research](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/data-science/market-research.md)\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.md b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.md deleted file mode 100644 index 0390be13c3..0000000000 --- a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/introduction.md +++ /dev/null @@ -1,110 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Introduction - -In this section, you will learn the fundamental principles of the cloud, then you will see why it can be interesting for you to use cloud services to run your data science projects and we'll look at some examples of data science projects run in the cloud. - -## What is the cloud? - -The Cloud, or Cloud Computing, is the delivery of a wide range of pay-as-you-go computing services hosted on infrastructure over the internet. Services include solutions such as storage, databases, networking, software, analytics, and intelligent services. - -We usually differentiate the Public, Private and Hybrid clouds as follows: - -* Public cloud: a public cloud is owned and operated by a third-party cloud service provider which delivers its computing resources over the Internet to the public. -* Private cloud: refers to cloud computing resources used exclusively by a single business or organization, with services and infrastructure maintained on a private network. -* Hybrid cloud: the hybrid cloud is a system that combines public and private clouds. Users opt for an on-premises data center while allowing data and applications to be run on one or more public clouds. - -Most cloud computing services fall into three categories: Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS). - -* Infrastructure as a Service (IaaS): users rent an IT infrastructure such as servers and virtual machines (VMs), storage, networks, operating systems -* Platform as a Service (PaaS): users rent an environment for developing, testing, delivering, and managing software applications. Users don’t need to worry about setting up or managing the underlying infrastructure of servers, storage, network, and databases needed for development. -* Software as a Service (SaaS): users get access to software applications over the Internet, on-demand and typically on a subscription basis. Users don’t need to worry about hosting and managing the software application, the underlying infrastructure or the maintenance, like software upgrades and security patching. - -Some of the largest Cloud providers are Amazon Web Services, Google Cloud Platform and Microsoft Azure. - -## Why choose the cloud for Data Science? - -Developers and IT professionals chose to work with the Cloud for many reasons, including the following: - -* Innovation: you can power your applications by integrating innovative services created by Cloud providers directly into your apps. -* Flexibility: you only pay for the services that you need and can choose from a wide range of services. You typically pay as you go and adapt your services according to your evolving needs. -* Budget: you don’t need to make initial investments to purchase hardware and software, set up and run on-site data centers and you can just pay for what you use. -* Scalability: your resources can scale according to the needs of your project, which means that your apps can use more or less computing power, storage and bandwidth, by adapting to external factors at any given time. -* Productivity: you can focus on your business rather than spending time on tasks that can be managed by someone else, such as managing data centers. -* Reliability: Cloud Computing offers several ways to continuously back up your data and you can set up disaster recovery plans to keep your business and services going, even in times of crisis. -* Security: you can benefit from policies, technologies and controls that strengthen the security of your project. - -These are some of the most common reasons why people choose to use Cloud services. Now that we have a better understanding of what the Cloud is and what its main benefits are, let's look more specifically into the jobs of Data scientists and developers working with data, and how the Cloud can help them with several challenges they might face: - -* Storing large amounts of data: instead of buying, managing and protecting big servers, you can store your data directly in the cloud, with solutions such as Azure Cosmos DB, Azure SQL Database and Azure Data Lake Storage. -* Performing Data Integration: data integration is an essential part of Data Science, that lets you make a transition from data collection to taking action. With data integration services offered in the cloud, you can collect, transform and integrate data from various sources into a single data warehouse, with Data Factory. -* Processing data: processing vast amounts of data requires a lot of computing power, and not everyone has access to machines powerful enough for that, which is why many people choose to directly harness the cloud’s huge computing power to run and deploy their solutions. -* Using data analytics services: cloud services like Azure Synapse Analytics, Azure Stream Analytics and Azure Databricks to help you turn your data into actionable insights. -* Using Machine Learning and data intelligence services: Instead of starting from scratch, you can use machine learning algorithms offered by the cloud provider, with services such as AzureML. You can also use cognitive services such as speech-to-text, text-to-speech, computer vision and more. - -## Examples of Data Science in the cloud - -Let’s make this more tangible by looking at a couple of scenarios. - -### Real-time social media sentiment analysis - -We’ll start with a scenario commonly studied by people who start with machine learning: social media sentiment analysis in real time. - -Let's say you run a news media website and you want to leverage live data to understand what content your readers could be interested in. To know more about that, you can build a program that performs real-time sentiment analysis of data from Twitter publications, on topics that are relevant to your readers. - -The key indicators you will look at are the volume of tweets on specific topics (hashtags) and sentiment, which is established using analytics tools that perform sentiment analysis around the specified topics. - -The steps necessary to create this project are as follows: - -* Create an event hub for streaming input, which will collect data from Twitter. -* Configure and start a Twitter client application, which will call the Twitter Streaming APIs. -* Create a Stream Analytics job. -* Specify the job input and query. -* Create an output sink and specify the job output. -* Start the job. - -To view the full process, check out the [documentation](https://docs.microsoft.com/azure/stream-analytics/stream-analytics-twitter-sentiment-analysis-trends?WT.mc_id=academic-77958-bethanycheum&ocid=AID30411099). - -### Scientific papers analysis - -Let’s take another example of a project created by [Dmitry Soshnikov](http://soshnikov.com), one of the authors of this curriculum. - -Dmitry created a tool that analyses COVID papers. By reviewing this project, you will see how you can create a tool that extracts knowledge from scientific papers, gains insights and helps researchers navigate through large collections of papers in an efficient way. - -Let's see the different steps used for this: - -* Extracting and pre-processing information with [Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). -* Using [Azure ML](https://azure.microsoft.com/services/machine-learning?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) to parallelize the processing. -* Storing and querying information with [Cosmos DB](https://azure.microsoft.com/services/cosmos-db?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). -* Create an interactive dashboard for data exploration and visualization using Power BI. - -To see the full process, visit [Dmitry’s blog](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/). - -As you can see, we can leverage Cloud services in many ways to perform Data Science. - -## Self study - -* [What Is Cloud Computing? A Beginner’s Guide | Microsoft Azure](https://azure.microsoft.com/overview/what-is-cloud-computing?ocid=AID3041109) -* [Social media analysis with Azure Stream Analytics | Microsoft Learn](https://docs.microsoft.com/azure/stream-analytics/stream-analytics-twitter-sentiment-analysis-trends?ocid=AID3041109) -* [Analyzing COVID Medical Papers with Azure and Text Analytics for Health](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/) - -## Your turn! 🚀 - -[Market research](../../assignments/data-science/market-research.md) - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter. diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.ipynb b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.ipynb new file mode 100644 index 0000000000..71891b7800 --- /dev/null +++ b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.ipynb @@ -0,0 +1,613 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "10efe4e8-7b3c-4532-b851-66332bc328de", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d328b78-aec2-4495-a449-b16032dd9615", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython azureml" + ] + }, + { + "cell_type": "markdown", + "id": "ce897deb", + "metadata": { + "tags": [] + }, + "source": [ + "\n", + "\n", + "# Data Science in the cloud: The \"Azure ML SDK\" way\n", + "\n", + "## Introduction\n", + "\n", + "### What is Azure ML SDK?\n", + "\n", + "Data scientists and AI developers use the Azure Machine Learning SDK to build and run Machine Learning workflows with the Azure Machine Learning service. You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE.\n", + "\n", + "Key areas of the SDK include:\n", + "\n", + "- Explore, prepare and manage the lifecycle of your datasets used in Machine Learning experiments.\n", + "- Manage cloud resources for monitoring, logging, and organizing your Machine Learning experiments.\n", + "- Train models either locally or by using cloud resources, including GPU-accelerated model training.\n", + "- Use automated Machine Learning, which accepts configuration parameters and training data. It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions.\n", + "- Deploy web services to convert your trained models into RESTful services that can be consumed in any application.\n", + "\n", + "[Learn more about the Azure Machine Learning SDK](https://docs.microsoft.com/python/api/overview/azure/ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109)\n", + "\n", + "In the [previous section](./the-low-code-no-code-way.md), we saw how to train, deploy and consume a model in a Low code/No code fashion. We used the Heart Failure dataset to generate and Heart failure prediction model. In this section, we are going to do the exact same thing but using the Azure Machine Learning SDK.\n", + "\n", + "![project-schema](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/project-schema.png)\n", + "\n", + "### Heart failure prediction project and dataset introduction\n", + "\n", + "Check [here](./the-low-code-no-code-way.md) the Heart failure prediction project and dataset introduction.\n", + "\n", + "## Training a model with the Azure ML SDK\n", + "\n", + "### Create an Azure ML workspace\n", + "\n", + "For simplicity, we are going to work on a Jupyter Notebook. This implies that you already have a Workspace and a compute instance. If you already have a Workspace, you can directly jump to section 2.3 Notebook creation.\n", + "\n", + "If not, please follow the instructions in section **2.1 Create an Azure ML workspace** in the [previous section](./the-low-code-no-code-way.md) to create a workspace.\n", + "\n", + "### Create a compute instance\n", + "\n", + "In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, go to the compute menu and you will see the different compute resources available\n", + "\n", + "![compute-instance-1](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/compute-instance-1.PNG)\n", + "\n", + "Let's create a compute instance to provision a Jupyter Notebook.\n", + "\n", + "1. Click on the + New button. \n", + "2. Give a name to your compute instance.\n", + "3. Choose your options: CPU or GPU, VM size and core number.\n", + "4. Click in the Create button.\n", + "\n", + "Congratulations, you have just created a compute instance! We will use this compute instance to create a Notebook in the [Creating Notebooks section](#23-creating-notebooks).\n", + "\n", + "### Loading the dataset\n", + "\n", + "Refer to the [previous section](./the-low-code-no-code-way.md) in the section [Loading the dataset](#loading-the-dataset) if you have not uploaded the dataset yet.\n", + "\n", + "### Creating Notebooks\n", + "\n", + ":::{note}\n", + "For the next step you can either create a new notebook from scratch, or you can upload the [notebook we created](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/data-science/data-science-in-the-cloud-the-azure-ml-sdk-way.ipynb) in you Azure ML Studio. To upload it, simply click on the \"Notebook\" menu and upload the notebook.\n", + ":::\n", + "\n", + "Notebooks are a really important part of the data science process. They can be used to Conduct Exploratory Data Analysis (EDA), call out to a computer cluster to train a model, and call out to an inference cluster to deploy an endpoint.\n", + "\n", + "To create a Notebook, we need a compute node that is serving out the Jupyter Notebook instance. Go back to the [Azure ML workspace](https://ml.azure.com/) and click on Compute instances. In the list of compute instances, you should see the [compute instance we created earlier](#create-a-compute-instance).\n", + "\n", + "1. In the Applications section, click on the Jupyter option.\n", + "2. Tick the \"Yes, I understand\" box and click on the Continue button.\n", + "![notebook-1](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/notebook-1.PNG)\n", + "1. This should open a new browser tab with your Jupyter Notebook instance as follow. Click on the \"New\" button to create a notebook.\n", + "\n", + "![notebook-2](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/notebook-2.PNG)\n", + "\n", + "Now that we have a Notebook, we can start training the model with Azure ML SDK.\n", + "\n", + "### Training a model\n", + "\n", + "First of all, if you ever have a doubt, refer to the [Azure ML SDK documentation](https://docs.microsoft.com/python/api/overview/azure/ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). It contains all the necessary information to understand the modules we are going to see in this section.\n", + "\n", + "#### Setup Workspace, experiment, compute cluster and dataset\n", + "\n", + "You need to load the `workspace` from the configuration file using the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6764ba31", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.core import Workspace\n", + "ws = Workspace.from_config()" + ] + }, + { + "cell_type": "markdown", + "id": "1350d570", + "metadata": {}, + "source": [ + "This returns an object of type `Workspace` that represents the workspace. You need to create an `experiment` using the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6dca29c5", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.core import Experiment\n", + "experiment_name = 'aml-experiment'\n", + "experiment = Experiment(ws, experiment_name)" + ] + }, + { + "cell_type": "markdown", + "id": "8b80dad1", + "metadata": {}, + "source": [ + "To get or create an experiment from a workspace, you request the experiment using the experiment name. Experiment name must be 3-36 characters, start with a letter or a number, and can only contain letters, numbers, underscores, and dashes. If the experiment is not found in the workspace, a new experiment is created.\n", + "\n", + "Now you need to create a compute cluster for the training using the following code. Note that this step can take a few minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76a2a067", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.core.compute import AmlCompute\n", + "\n", + "aml_name = \"heart-f-cluster\"\n", + "try:\n", + " aml_compute = AmlCompute(ws, aml_name)\n", + " print('Found existing AML compute context.')\n", + "except:\n", + " print('Creating new AML compute context.')\n", + " aml_config = AmlCompute.provisioning_configuration(vm_size=\"Standard_D2_v2\", min_nodes=1, max_nodes=3)\n", + " aml_compute = AmlCompute.create(ws, name=aml_name, provisioning_configuration=aml_config)\n", + " aml_compute.wait_for_completion(show_output=True)\n", + "\n", + "cts = ws.compute_targets\n", + "compute_target = cts[aml_name]" + ] + }, + { + "cell_type": "markdown", + "id": "5f9a5364", + "metadata": {}, + "source": [ + "You can get the dataset from the workspace using the dataset name in the following way:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f673ea26", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "dataset = ws.datasets['heart-failure-records']\n", + "df = dataset.to_pandas_dataframe()\n", + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "a5466359", + "metadata": {}, + "source": [ + "#### AutoML configuration and training\n", + "\n", + "To set the AutoML configuration, use the [AutoMLConfig class](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig(class)?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109).\n", + "\n", + "As described in the doc, there are a lot of parameters with which you can play with. For this project, we will use the following parameters:\n", + "\n", + "- `experiment_timeout_minutes`: The maximum amount of time (in minutes) that the experiment is allowed to run before it is automatically stopped and results are automatically made available\n", + "- `max_concurrent_iterations`: The maximum number of concurrent training iterations allowed for the experiment.\n", + "- `primary_metric`: The primary metric used to determine the experiment's status.\n", + "- `compute_target`: The Azure Machine Learning compute target to run the Automated Machine Learning experiment on.\n", + "- `task`: The type of task to run. Values can be 'classification', 'regression', or 'forecasting' depending on the type of automated ML problem to solve.\n", + "- `training_data`: The training data to be used within the experiment. It should contain both training features and a label column (optionally a sample weights column).\n", + "- `label_column_name`: The name of the label column.\n", + "- `path`: The full path to the Azure Machine Learning project folder.\n", + "- `enable_early_stopping`: Whether to enable early termination if the score is not improving in the short term.\n", + "- `featurization`: Indicator for whether the featurization step should be done automatically or not, or whether customized featurization should be used.\n", + "- `debug_log`: The log file to write debug information to." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e2d6adb", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.train.automl import AutoMLConfig\n", + "\n", + "project_folder = './aml-project'\n", + "\n", + "automl_settings = {\n", + " \"experiment_timeout_minutes\": 20,\n", + " \"max_concurrent_iterations\": 3,\n", + " \"primary_metric\" : 'AUC_weighted'\n", + "}\n", + "\n", + "automl_config = AutoMLConfig(compute_target=compute_target,\n", + " task = \"classification\",\n", + " training_data=dataset,\n", + " label_column_name=\"DEATH_EVENT\",\n", + " path = project_folder, \n", + " enable_early_stopping= True,\n", + " featurization= 'auto',\n", + " debug_log = \"automl_errors.log\",\n", + " **automl_settings\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "416b882b", + "metadata": {}, + "source": [ + "Now that you have your configuration set, you can train the model using the following code. This step can take up to an hour depending on your cluster size." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27235651", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "remote_run = experiment.submit(automl_config)" + ] + }, + { + "cell_type": "markdown", + "id": "c1259456", + "metadata": {}, + "source": [ + "You can run the RunDetails widget to show the different experiments." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de0410e3", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.widgets import RunDetails\n", + "RunDetails(remote_run).show()" + ] + }, + { + "cell_type": "markdown", + "id": "5698ca64", + "metadata": {}, + "source": [ + "## Model deployment and endpoint consumption with the Azure ML SDK\n", + "\n", + "### Saving the best model\n", + "\n", + "The `remote_run` is an object of type [AutoMLRun](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.run.automlrun?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). This object contains the method `get_output()` which returns the best run and the corresponding fitted model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5902263", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "best_run, fitted_model = remote_run.get_output()" + ] + }, + { + "cell_type": "markdown", + "id": "6aafe503", + "metadata": {}, + "source": [ + "You can see the parameters used for the best model by just printing the fitted_model and see the properties of the best model by using the [get_properties()](https://docs.microsoft.com/python/api/azureml-core/azureml.core.run(class)?view=azure-ml-py#azureml_core_Run_get_properties?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "374d3f21", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "best_run.get_properties()" + ] + }, + { + "cell_type": "markdown", + "id": "07b9aac7", + "metadata": {}, + "source": [ + "Now register the model with the [register_model](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.run.automlrun?view=azure-ml-py#register-model-model-name-none--description-none--tags-none--iteration-none--metric-none-?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86b307f0", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "model_name = best_run.properties['model_name']\n", + "script_file_name = 'inference/score.py'\n", + "best_run.download_file('outputs/scoring_file_v_1_0_0.py', 'inference/score.py')\n", + "description = \"aml heart failure project sdk\"\n", + "model = best_run.register_model(\n", + " model_name = model_name,\n", + " model_path = './outputs/',\n", + " description = description,\n", + " tags = None\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "6b760b6a", + "metadata": {}, + "source": [ + "### Model deployment\n", + "\n", + "Once the best model is saved, we can deploy it with the [InferenceConfig](https://docs.microsoft.com/python/api/azureml-core/azureml.core.model.inferenceconfig?view=azure-ml-py?ocid=AID3041109) class. InferenceConfig represents the configuration settings for a custom environment used for deployment. The [AciWebservice](https://docs.microsoft.com/python/api/azureml-core/azureml.core.webservice.aciwebservice?view=azure-ml-py) class represents a Machine Learning model deployed as a web service endpoint on Azure Container Instances. A deployed service is created from a model, script, and associated files. The resulting web service is a load-balanced, HTTP endpoint with a REST API. You can send data to this API and receive the prediction returned by the model.\n", + "\n", + "The model is deployed using the [deploy](https://docs.microsoft.com/python/api/azureml-core/azureml.core.model(class)?view=azure-ml-py#deploy-workspace--name--models--inference-config-none--deployment-config-none--deployment-target-none--overwrite-false--show-output-false-?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "63ca096a", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "from azureml.core.model import InferenceConfig, Model\n", + "from azureml.core.webservice import AciWebservice\n", + "\n", + "inference_config = InferenceConfig(entry_script=script_file_name, environment=best_run.get_environment())\n", + "\n", + "aciconfig = AciWebservice.deploy_configuration(\n", + " cpu_cores = 1,\n", + " memory_gb = 1,\n", + " tags = {'type': \"automl-heart-failure-prediction\"},\n", + " description = 'Sample service for AutoML Heart Failure Prediction'\n", + ")\n", + "\n", + "aci_service_name = 'automl-hf-sdk'\n", + "aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig)\n", + "aci_service.wait_for_deployment(True)\n", + "print(aci_service.state)" + ] + }, + { + "cell_type": "markdown", + "id": "042a5d97", + "metadata": {}, + "source": [ + "This step should take a few minutes.\n", + "\n", + "### Endpoint consumption\n", + "\n", + "You consume your endpoint by creating a sample input:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8501e73d", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "data = {\n", + " \"data\":\n", + " [\n", + " {\n", + " 'age': \"60\",\n", + " 'anaemia': \"false\",\n", + " 'creatinine_phosphokinase': \"500\",\n", + " 'diabetes': \"false\",\n", + " 'ejection_fraction': \"38\",\n", + " 'high_blood_pressure': \"false\",\n", + " 'platelets': \"260000\",\n", + " 'serum_creatinine': \"1.40\",\n", + " 'serum_sodium': \"137\",\n", + " 'sex': \"false\",\n", + " 'smoking': \"false\",\n", + " 'time': \"130\",\n", + " },\n", + " ],\n", + "}\n", + "\n", + "test_sample = str.encode(json.dumps(data))" + ] + }, + { + "cell_type": "markdown", + "id": "b138d435", + "metadata": {}, + "source": [ + "And then you can send this input to your model for prediction :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "406240b7", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "response = aci_service.run(input_data=test_sample)\n", + "response" + ] + }, + { + "cell_type": "markdown", + "id": "ee723fae", + "metadata": {}, + "source": [ + "This should output `'{\"result\": [false]}'`. This means that the patient input we sent to the endpoint generated the prediction `false` which means this person is not likely to have a heart attack.\n", + "\n", + "Congratulations! You just consumed the model deployed and trained on Azure ML with the Azure ML SDK!\n", + "\n", + ":::{note}\n", + "Once you are done with the project, don't forget to delete all the resources.\n", + ":::\n", + "\n", + "## Your turn! 🚀\n", + "\n", + " There are many other things you can do through the SDK, unfortunately, we can not view them all in this section. But good news, learning how to skim through the SDK documentation can take you a long way on your own. Have a look at the Azure ML SDK documentation and find the `Pipeline` class that allows you to create pipelines. A Pipeline is a collection of steps which can be executed as a workflow.\n", + "\n", + ":::{note}\n", + "**HINT:** Go to the [SDK documentation](https://docs.microsoft.com/python/api/overview/azure/ml/?view=azure-ml-py?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) and type keywords in the search bar like \"Pipeline\". You should have the `azureml.pipeline.core.Pipeline` class in the search results.\n", + ":::\n", + "\n", + "Assignment - [Data Science project using Azure ML SDK](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/data-science/data-science-project-using-azure-ml-sdk.md)\n", + "\n", + "## Self study\n", + "\n", + "In this section, you learned how to train, deploy and consume a model to predict heart failure risk with the Azure ML SDK in the cloud. Check this [documentation](https://docs.microsoft.com/python/api/overview/azure/ml/?view=azure-ml-py?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) for further information about the Azure ML SDK. Try to create your own model with the Azure ML SDK.\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.md b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.md deleted file mode 100644 index c0c9d35c1f..0000000000 --- a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-azure-ml-sdk-way.md +++ /dev/null @@ -1,309 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Data Science in the cloud: The "Azure ML SDK" way - -## Introduction - -### What is Azure ML SDK? - -Data scientists and AI developers use the Azure Machine Learning SDK to build and run Machine Learning workflows with the Azure Machine Learning service. You can interact with the service in any Python environment, including Jupyter Notebooks, Visual Studio Code, or your favorite Python IDE. - -Key areas of the SDK include: - -- Explore, prepare and manage the lifecycle of your datasets used in Machine Learning experiments. -- Manage cloud resources for monitoring, logging, and organizing your Machine Learning experiments. -- Train models either locally or by using cloud resources, including GPU-accelerated model training. -- Use automated Machine Learning, which accepts configuration parameters and training data. It automatically iterates through algorithms and hyperparameter settings to find the best model for running predictions. -- Deploy web services to convert your trained models into RESTful services that can be consumed in any application. - -[Learn more about the Azure Machine Learning SDK](https://docs.microsoft.com/python/api/overview/azure/ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) - -In the [previous section](./the-low-code-no-code-way.md), we saw how to train, deploy and consume a model in a Low code/No code fashion. We used the Heart Failure dataset to generate and Heart failure prediction model. In this section, we are going to do the exact same thing but using the Azure Machine Learning SDK. - -![project-schema](../../../images/project-schema.png) - -### Heart failure prediction project and dataset introduction - -Check [here](./the-low-code-no-code-way.md) the Heart failure prediction project and dataset introduction. - -## Training a model with the Azure ML SDK - -### Create an Azure ML workspace - -For simplicity, we are going to work on a Jupyter Notebook. This implies that you already have a Workspace and a compute instance. If you already have a Workspace, you can directly jump to section 2.3 Notebook creation. - -If not, please follow the instructions in section **2.1 Create an Azure ML workspace** in the [previous section](./the-low-code-no-code-way.md) to create a workspace. - -### Create a compute instance - -In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, go to the compute menu and you will see the different compute resources available - -![compute-instance-1](../../../images/compute-instance-1.PNG) - -Let's create a compute instance to provision a Jupyter Notebook. - -1. Click on the + New button. -2. Give a name to your compute instance. -3. Choose your options: CPU or GPU, VM size and core number. -4. Click in the Create button. - -Congratulations, you have just created a compute instance! We will use this compute instance to create a Notebook in the [Creating Notebooks section](#23-creating-notebooks). - -### Loading the dataset - -Refer to the [previous section](./the-low-code-no-code-way.md) in the section [Loading the dataset](#loading-the-dataset) if you have not uploaded the dataset yet. - -### Creating Notebooks - -```{note} -For the next step you can either create a new notebook from scratch, or you can upload the [notebook we created](../../assignments/data-science/data-science-in-the-cloud-the-azure-ml-sdk-way.ipynb) in you Azure ML Studio. To upload it, simply click on the "Notebook" menu and upload the notebook. -``` - -Notebooks are a really important part of the data science process. They can be used to Conduct Exploratory Data Analysis (EDA), call out to a computer cluster to train a model, and call out to an inference cluster to deploy an endpoint. - -To create a Notebook, we need a compute node that is serving out the Jupyter Notebook instance. Go back to the [Azure ML workspace](https://ml.azure.com/) and click on Compute instances. In the list of compute instances, you should see the [compute instance we created earlier](#create-a-compute-instance). - -1. In the Applications section, click on the Jupyter option. -2. Tick the "Yes, I understand" box and click on the Continue button. -![notebook-1](../../../images/notebook-1.PNG) -3. This should open a new browser tab with your Jupyter Notebook instance as follow. Click on the "New" button to create a notebook. - -![notebook-2](../../../images/notebook-2.PNG) - -Now that we have a Notebook, we can start training the model with Azure ML SDK. - -### Training a model - -First of all, if you ever have a doubt, refer to the [Azure ML SDK documentation](https://docs.microsoft.com/python/api/overview/azure/ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). It contains all the necessary information to understand the modules we are going to see in this section. - -#### Setup Workspace, experiment, compute cluster and dataset - -You need to load the `workspace` from the configuration file using the following code: - -```python -from azureml.core import Workspace -ws = Workspace.from_config() -``` - -This returns an object of type `Workspace` that represents the workspace. You need to create an `experiment` using the following code: - -```python -from azureml.core import Experiment -experiment_name = 'aml-experiment' -experiment = Experiment(ws, experiment_name) -``` - -To get or create an experiment from a workspace, you request the experiment using the experiment name. Experiment name must be 3-36 characters, start with a letter or a number, and can only contain letters, numbers, underscores, and dashes. If the experiment is not found in the workspace, a new experiment is created. - -Now you need to create a compute cluster for the training using the following code. Note that this step can take a few minutes. - -```python -from azureml.core.compute import AmlCompute - -aml_name = "heart-f-cluster" -try: - aml_compute = AmlCompute(ws, aml_name) - print('Found existing AML compute context.') -except: - print('Creating new AML compute context.') - aml_config = AmlCompute.provisioning_configuration(vm_size="Standard_D2_v2", min_nodes=1, max_nodes=3) - aml_compute = AmlCompute.create(ws, name=aml_name, provisioning_configuration=aml_config) - aml_compute.wait_for_completion(show_output=True) - -cts = ws.compute_targets -compute_target = cts[aml_name] -``` - -You can get the dataset from the workspace using the dataset name in the following way: - -```python -dataset = ws.datasets['heart-failure-records'] -df = dataset.to_pandas_dataframe() -df.describe() -``` - -#### AutoML configuration and training - -To set the AutoML configuration, use the [AutoMLConfig class](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.automlconfig(class)?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). - -As described in the doc, there are a lot of parameters with which you can play with. For this project, we will use the following parameters: - -- `experiment_timeout_minutes`: The maximum amount of time (in minutes) that the experiment is allowed to run before it is automatically stopped and results are automatically made available -- `max_concurrent_iterations`: The maximum number of concurrent training iterations allowed for the experiment. -- `primary_metric`: The primary metric used to determine the experiment's status. -- `compute_target`: The Azure Machine Learning compute target to run the Automated Machine Learning experiment on. -- `task`: The type of task to run. Values can be 'classification', 'regression', or 'forecasting' depending on the type of automated ML problem to solve. -- `training_data`: The training data to be used within the experiment. It should contain both training features and a label column (optionally a sample weights column). -- `label_column_name`: The name of the label column. -- `path`: The full path to the Azure Machine Learning project folder. -- `enable_early_stopping`: Whether to enable early termination if the score is not improving in the short term. -- `featurization`: Indicator for whether the featurization step should be done automatically or not, or whether customized featurization should be used. -- `debug_log`: The log file to write debug information to. - -```python -from azureml.train.automl import AutoMLConfig - -project_folder = './aml-project' - -automl_settings = { - "experiment_timeout_minutes": 20, - "max_concurrent_iterations": 3, - "primary_metric" : 'AUC_weighted' -} - -automl_config = AutoMLConfig(compute_target=compute_target, - task = "classification", - training_data=dataset, - label_column_name="DEATH_EVENT", - path = project_folder, - enable_early_stopping= True, - featurization= 'auto', - debug_log = "automl_errors.log", - **automl_settings - ) -``` - -Now that you have your configuration set, you can train the model using the following code. This step can take up to an hour depending on your cluster size. - -```python -remote_run = experiment.submit(automl_config) -``` - -You can run the RunDetails widget to show the different experiments. - -```python -from azureml.widgets import RunDetails -RunDetails(remote_run).show() -``` - -## Model deployment and endpoint consumption with the Azure ML SDK - -### Saving the best model - -The `remote_run` is an object of type [AutoMLRun](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.run.automlrun?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). This object contains the method `get_output()` which returns the best run and the corresponding fitted model. - -```python -best_run, fitted_model = remote_run.get_output() -``` - -You can see the parameters used for the best model by just printing the fitted_model and see the properties of the best model by using the [get_properties()](https://docs.microsoft.com/python/api/azureml-core/azureml.core.run(class)?view=azure-ml-py#azureml_core_Run_get_properties?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method. - -```python -best_run.get_properties() -``` - -Now register the model with the [register_model](https://docs.microsoft.com/python/api/azureml-train-automl-client/azureml.train.automl.run.automlrun?view=azure-ml-py#register-model-model-name-none--description-none--tags-none--iteration-none--metric-none-?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method. - -```python -model_name = best_run.properties['model_name'] -script_file_name = 'inference/score.py' -best_run.download_file('outputs/scoring_file_v_1_0_0.py', 'inference/score.py') -description = "aml heart failure project sdk" -model = best_run.register_model( - model_name = model_name, - model_path = './outputs/', - description = description, - tags = None -) -``` - -### Model deployment - -Once the best model is saved, we can deploy it with the [InferenceConfig](https://docs.microsoft.com/python/api/azureml-core/azureml.core.model.inferenceconfig?view=azure-ml-py?ocid=AID3041109) class. InferenceConfig represents the configuration settings for a custom environment used for deployment. The [AciWebservice](https://docs.microsoft.com/python/api/azureml-core/azureml.core.webservice.aciwebservice?view=azure-ml-py) class represents a Machine Learning model deployed as a web service endpoint on Azure Container Instances. A deployed service is created from a model, script, and associated files. The resulting web service is a load-balanced, HTTP endpoint with a REST API. You can send data to this API and receive the prediction returned by the model. - -The model is deployed using the [deploy](https://docs.microsoft.com/python/api/azureml-core/azureml.core.model(class)?view=azure-ml-py#deploy-workspace--name--models--inference-config-none--deployment-config-none--deployment-target-none--overwrite-false--show-output-false-?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) method. - -```python -from azureml.core.model import InferenceConfig, Model -from azureml.core.webservice import AciWebservice - -inference_config = InferenceConfig(entry_script=script_file_name, environment=best_run.get_environment()) - -aciconfig = AciWebservice.deploy_configuration( - cpu_cores = 1, - memory_gb = 1, - tags = {'type': "automl-heart-failure-prediction"}, - description = 'Sample service for AutoML Heart Failure Prediction' -) - -aci_service_name = 'automl-hf-sdk' -aci_service = Model.deploy(ws, aci_service_name, [model], inference_config, aciconfig) -aci_service.wait_for_deployment(True) -print(aci_service.state) -``` - -This step should take a few minutes. - -### Endpoint consumption - -You consume your endpoint by creating a sample input: - -```python -data = { - "data": - [ - { - 'age': "60", - 'anaemia': "false", - 'creatinine_phosphokinase': "500", - 'diabetes': "false", - 'ejection_fraction': "38", - 'high_blood_pressure': "false", - 'platelets': "260000", - 'serum_creatinine': "1.40", - 'serum_sodium': "137", - 'sex': "false", - 'smoking': "false", - 'time': "130", - }, - ], -} - -test_sample = str.encode(json.dumps(data)) -``` - -And then you can send this input to your model for prediction : - -```python -response = aci_service.run(input_data=test_sample) -response -``` - -This should output `'{"result": [false]}'`. This means that the patient input we sent to the endpoint generated the prediction `false` which means this person is not likely to have a heart attack. - -Congratulations! You just consumed the model deployed and trained on Azure ML with the Azure ML SDK! - -```{note} -Once you are done with the project, don't forget to delete all the resources. -``` - -## Your turn! 🚀 - - There are many other things you can do through the SDK, unfortunately, we can not view them all in this section. But good news, learning how to skim through the SDK documentation can take you a long way on your own. Have a look at the Azure ML SDK documentation and find the `Pipeline` class that allows you to create pipelines. A Pipeline is a collection of steps which can be executed as a workflow. - -```{note} -**HINT:** Go to the [SDK documentation](https://docs.microsoft.com/python/api/overview/azure/ml/?view=azure-ml-py?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) and type keywords in the search bar like "Pipeline". You should have the `azureml.pipeline.core.Pipeline` class in the search results. -``` - -Assignment - [Data Science project using Azure ML SDK](../../assignments/data-science/data-science-project-using-azure-ml-sdk.md) - -## Self study - -In this section, you learned how to train, deploy and consume a model to predict heart failure risk with the Azure ML SDK in the cloud. Check this [documentation](https://docs.microsoft.com/python/api/overview/azure/ml/?view=azure-ml-py?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) for further information about the Azure ML SDK. Try to create your own model with the Azure ML SDK. - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter. diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.ipynb b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.ipynb new file mode 100644 index 0000000000..bb7978f63c --- /dev/null +++ b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.ipynb @@ -0,0 +1,462 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "49bb1540-b0f6-4e28-9c34-b9d86bfe4f17", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a80de56-2278-4fd1-941e-c11d67db53e9", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" + ] + }, + { + "cell_type": "markdown", + "id": "079cbda6", + "metadata": {}, + "source": [ + "# The \"low code/no code\" way\n", + "\n", + "## What is Azure Machine Learning(ML)?\n", + "\n", + "The Azure cloud platform is more than 200 products and cloud services designed to help you bring new solutions to life. Data scientists expend a lot of effort exploring and pre-processing data and trying various types of model-training algorithms to produce accurate models. These tasks are time-consuming and often make inefficient use of expensive compute hardware.\n", + "\n", + "[Azure ML](https://docs.microsoft.com/azure/machine-learning/overview-what-is-azure-machine-learning?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) is a cloud-based platform for building and operating Machine Learning solutions in Azure. It includes a wide range of features and capabilities that help data scientists prepare data, train models, publish predictive services, and monitor their usage. Most importantly, it helps them to increase their efficiency by automating many of the time-consuming tasks associated with training models; and it enables them to use cloud-based compute resources that scale effectively, to handle large volumes of data while incurring costs only when actually used.\n", + "\n", + "Azure ML provides all the tools developers and data scientists need for their Machine Learning workflows. These include:\n", + "\n", + "- **Azure Machine Learning Studio**: it is a web portal in Azure Machine Learning for low-code and no-code options for model training, deployment, automation, tracking and asset management. The studio integrates with the Azure Machine Learning SDK for a seamless experience.\n", + "- **Jupyter Notebooks**: quickly prototype and test ML models.\n", + "- **Azure Machine Learning Designer**: allows to drag-n-drop modules to build experiments and then deploy pipelines in a low-code environment.\n", + "- **Automated Machine Learning UI (AutoML)** : automates iterative tasks of Machine Learning model development, allowing to build Machine Learning models with high scale, efficiency, and productivity, all while sustaining model quality.\n", + "- **Data Labelling**: an assisted ML tool to automatically label data.\n", + "- **Machine Learning extension for Visual Studio Code**: provides a full-featured development environment for building and managing Machine Learning projects.\n", + "- **Machine Learning CLI**: provides commands for managing Azure ML resources from the command line.\n", + "- **Integration with open-source frameworks** such as PyTorch, TensorFlow, Scikit-learn and many more for training, deploying and managing the end-to-end Machine Learning process.\n", + "- **MLflow**: It is an open-source library for managing the life cycle of your Lachine Learning experiments. **MLflow Tracking** is a component of MLflow that logs and tracks your training run metrics and model artifacts, irrespective of your experiment's environment.\n", + "\n", + "## The heart failure prediction project\n", + "\n", + "There is no doubt that making and building projects are the best way to put your skills and knowledge to the test. In this section, we are going to explore two different ways of building a data science project for the prediction of heart failure attacks in Azure ML Studio, through Low code/No code and through the Azure ML SDK as shown in the following schema:\n", + "\n", + "![project-schema](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/project-schema.png)\n", + "\n", + "Each way has its own pros and cons. The Low code/No code way is easier to start with as it involves interacting with a GUI (Graphical User Interface), with no prior knowledge of code required. This method enables quick testing of the project's viability and to create POC (Proof Of Concept). However, as the project grows and things need to be production ready, it is not feasible to create resources through GUI. We need to programmatically automate everything, from the creation of resources to the deployment of a model. This is where knowing how to use the Azure ML SDK becomes crucial.\n", + "\n", + "| | Low code/no code | Azure ML SDK |\n", + "|-------------------|------------------|---------------------------|\n", + "| Expertise in code | Not required | Required |\n", + "| Time to develop | Fast and easy | Depends on code expertise |\n", + "| Production ready | No | Yes |\n", + "\n", + "## The heart failure dataset\n", + "\n", + "Cardiovascular diseases (CVDs) are the number 1 cause of death globally, accounting for 31% of all deaths worldwide. Environmental and behavioral risk factors such as use of tobacco, unhealthy diet and obesity, physical inactivity and harmful use of alcohol could be used as features for estimation models. Being able to estimate the probability of the development of a CVD could be of great use to prevent attacks in high-risk people.\n", + "\n", + "Kaggle has made a [Heart Failure dataset](https://www.kaggle.com/andrewmvd/heart-failure-clinical-data) publicly available, that we are going to use for this project. You can download the dataset now. This is a tabular dataset with 13 columns (12 features and 1 target variable) and 299 rows.\n", + "\n", + "| | Variable name | Type | Description | Example |\n", + "|----|---------------------------|-----------------|-----------------------------------------------------------|-------------------|\n", + "| 1 | age | numerical | age of the patient | 25 |\n", + "| 2 | anaemia | boolean | Decrease of red blood cells or haemoglobin | 0 or 1 |\n", + "| 3 | creatinine_phosphokinase | numerical | Level of CPK enzyme in the blood | 542 |\n", + "| 4 | diabetes | boolean | If the patient has diabetes | 0 or 1 |\n", + "| 5 | ejection_fraction | numerical | Percentage of blood leaving the heart on each contraction | 45 |\n", + "| 6 | high_blood_pressure | boolean | If the patient has hypertension | 0 or 1 |\n", + "| 7 | platelets | numerical | Platelets in the blood | 149000 |\n", + "| 8 | serum_creatinine | numerical | Level of serum creatinine in the blood | 0.5 |\n", + "| 9 | serum_sodium | numerical | Level of serum sodium in the blood | jun |\n", + "| 10 | sex | boolean | woman or man | 0 or 1 |\n", + "| 11 | smoking | boolean | If the patient smokes | 0 or 1 |\n", + "| 12 | time | numerical | follow-up period (days) | 4 |\n", + "|----|---------------------------|-----------------|-----------------------------------------------------------|-------------------|\n", + "| 21 | DEATH_EVENT [Target] | boolean | if the patient dies during the follow-up period | 0 or 1 |\n", + "\n", + "Once you have the dataset, we can start the project in Azure.\n", + "\n", + "## Low code/no code training of a model in Azure ML Studio\n", + "\n", + "### Create an Azure ML workspace\n", + "\n", + "To train a model in Azure ML you first need to create an Azure ML workspace. The workspace is the top-level resource for Azure Machine Learning, providing a centralized place to work with all the artifacts you create when you use Azure Machine Learning. The workspace keeps a history of all training runs, including logs, metrics, output, and a snapshot of your scripts. You use this information to determine which training run produces the best model. [Learn more](https://docs.microsoft.com/azure/machine-learning/concept-workspace?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109).\n", + "\n", + "It is recommended to use the most up-to-date browser that's compatible with your operating system. The following browsers are supported:\n", + "\n", + "- Microsoft Edge (The new Microsoft Edge, the latest version. Not Microsoft Edge legacy)\n", + "- Safari (latest version, Mac only)\n", + "- Chrome (latest version)\n", + "- Firefox (latest version)\n", + "\n", + "To use Azure Machine Learning, create a workspace in your Azure subscription. You can then use this workspace to manage data, compute resources, code, models, and other artifacts related to your Machine Learning workloads.\n", + "\n", + ":::{note}\n", + "Your Azure subscription will be charged a small amount for data storage as long as the Azure Machine Learning workspace exists in your subscription, so we recommend you to delete the Azure Machine Learning workspace when you are no longer using it.\n", + ":::\n", + "\n", + "1\\. Sign in to the [Azure portal](https://ms.portal.azure.com/) using the Microsoft credentials associated with your Azure subscription.\n", + "\n", + "2\\. Select **＋Create a resource**.\n", + "\n", + "![workspace-1](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-1.PNG)\n", + "\n", + "Search for Machine Learning and select the Machine Learning tile.\n", + "\n", + "![workspace-2](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-2.PNG)\n", + "\n", + "Click the create button.\n", + "\n", + "![workspace-3](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-3.PNG)\n", + "\n", + "Fill in the settings as follows:\n", + "\n", + "- Subscription: Your Azure subscription.\n", + "- Resource group: Create or select a resource group.\n", + "- Workspace name: Enter a unique name for your workspace.\n", + "- Region: Select the geographical region closest to you.\n", + "- Storage account: Note the default new storage account that will be created for your workspace.\n", + "- Key vault: Note the default new key vault that will be created for your workspace.\n", + "- Application insights: Note the default new application insights resource that will be created for your workspace.\n", + "- Container registry: None (one will be created automatically the first time you deploy a model to a container)\n", + " ![workspace-4](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-4.PNG).\n", + "- Click the create + review and then on the create button.\n", + " \n", + "3\\. Wait for your workspace to be created (this can take a few minutes). Then go to it in the portal. You can find it through the Machine Learning Azure service.\n", + "\n", + "4\\. On the Overview page for your workspace, launch Azure Machine Learning studio (or open a new browser tab and navigate to [Azure ML](https://ml.azure.com), and sign into Azure Machine Learning studio using your Microsoft account. If prompted, select your Azure directory and subscription, and your Azure Machine Learning workspace.\n", + "\n", + "![workspace-5](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-5.PNG)\n", + "\n", + "5\\. In Azure Machine Learning Studio, toggle the 鈽?icon at the top left to view the various pages in the interface. You can use these pages to manage the resources in your workspace.\n", + "\n", + "![workspace-6](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/workspace-6.PNG)\n", + "\n", + "You can manage your workspace using the Azure portal, but for data scientists and Machine Learning operations engineers, Azure Machine Learning Studio provides a more focused user interface for managing workspace resources.\n", + "\n", + "### Compute resources\n", + "\n", + "Compute Resources are cloud-based resources on which you can run model training and data exploration processes. There are four kinds of compute resource you can create:\n", + "\n", + "- **Compute Instances**: Development workstations that data scientists can use to work with data and models. This involves the creation of a Virtual Machine (VM) and launching a notebook instance. You can then train a model by calling a computer cluster from the notebook.\n", + "- **Compute Clusters**: Scalable clusters of VMs for on-demand processing of experiment code. You will need it when training a model. Compute clusters can also employ specialized GPU or CPU resources.\n", + "- **Inference Clusters**: Deployment targets for predictive services that use your trained models.\n", + "- **Attached Compute**: Links to existing Azure compute resources, such as Virtual Machines or Azure Databricks clusters.\n", + "\n", + "### Choosing the right options for your compute resources\n", + "\n", + "Some key factors are to consider when creating a compute resource and those choices can be critical decisions to make. \n", + "\n", + "**Do you need CPU or GPU?**\n", + "\n", + "A CPU (Central Processing Unit) is the electronic circuitry that executes instructions comprising a computer program. A GPU (Graphics Processing Unit) is a specialized electronic circuit that can execute graphics-related code at a very high rate. \n", + "\n", + "The main difference between CPU and GPU architecture is that a CPU is designed to handle a wide-range of tasks quickly (as measured by CPU clock speed), but are limited in the concurrency of tasks that can be running. GPUs are designed for parallel computing and therefore are much better at deep learning tasks.\n", + "\n", + "| CPU | GPU |\n", + "|-----------------------------------------|-----------------------------|\n", + "| Less expensive | More expensive |\n", + "| Lower level of concurrency | Higher level of concurrency |\n", + "| Slower in training deep learning models | Optimal for deep learning |\n", + "\n", + "**Cluster size**\n", + "\n", + "Larger clusters are more expensive but will result in better responsiveness. Therefore, if you have time but not enough money, you should start with a small cluster. Conversely, if you have money but not much time, you should start with a larger cluster.\n", + "\n", + "**VM size**\n", + "\n", + "Depending on your time and budgetary constraints, you can vary the size of your RAM, disk, number of cores and clock speed. Increasing all those parameters will be costlier, but will result in better performance.\n", + "\n", + "**Dedicated or low-priority instances?**\n", + "\n", + "A low-priority instance means that it is interruptible: essentially, Microsoft Azure can take those resources and assign them to another task, thus interrupting a job. A dedicated instance, or non-interruptible, means that the job will never be terminated without your permission.\n", + "This is another consideration of time vs money, since interruptible instances are less expensive than dedicated ones.\n", + "\n", + "### Creating a compute cluster\n", + "\n", + "In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, go to compute and you will be able to see the different compute resources we just discussed (i.e compute instances, compute clusters, inference clusters and attached compute). For this project, we are going to need a compute cluster for model training. In the Studio, Click on the \"Compute\" menu, then the \"Compute cluster\" tab and click on the \"+ New\" button to create a compute cluster.\n", + "\n", + "![22](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/cluster-1.PNG)\n", + "\n", + "6\\. Choose your options: Dedicated vs Low priority, CPU or GPU, VM size and core number (you can keep the default settings for this project).\n", + "\n", + "7\\. Click on the Next button.\n", + "\n", + "![23](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/cluster-2.PNG)\n", + "\n", + "8\\. Give the cluster a compute name\n", + "\n", + "9\\. Choose your options: Minimum/Maximum number of nodes, Idle seconds before scale down, SSH access. Note that if the minimum number of nodes is 0, you will save money when the cluster is idle. Note that the higher the number of maximum nodes, the shorter the training will be. The maximum number of nodes recommended is 3. \n", + "\n", + "10\\. Click on the \"Create\" button. This step may take a few minutes.\n", + "![29](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/cluster-3.PNG)\n", + "\n", + "Awesome! Now that we have a Compute cluster, we need to load the data to Azure ML Studio.\n", + "\n", + "### Loading the dataset\n", + "\n", + "11\\. In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, click on \"Datasets\" in the left menu and click on the \"+ Create dataset\" button to create a dataset. Choose the \"From local files\" option and select the Kaggle dataset we downloaded earlier.\n", + "![24](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/dataset-1.PNG)\n", + "\n", + "12\\. Give your dataset a name, a type and a description. Click Next. Upload the data from files. Click Next.\n", + "![25](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/dataset-2.PNG)\n", + "\n", + "13\\. In the Schema, change the data type to Boolean for the following features: anemia, diabetes, high blood pressure, sex, smoking, and DEATH_EVENT. Click Next and Click Create.\n", + "![26](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/dataset-3.PNG)\n", + "\n", + "Great! Now that the dataset is in place and the compute cluster is created, we can start the training of the model!\n", + "\n", + "## Low code/no code training with AutoML\n", + "\n", + "Traditional Machine Learning model development is resource-intensive, requires significant domain knowledge and time to produce and compare dozens of models. \n", + "Automated Machine Learning (AutoML), is the process of automating the time-consuming, iterative tasks of Machine Learning model development. It allows data scientists, analysts, and developers to build ML models with high scale, efficiency, and productivity, all while sustaining model quality. It reduces the time it takes to get production-ready ML models, with great ease and efficiency. [Learn more](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109)\n", + "\n", + "14\\. In the [Azure ML workspace](https://ml.azure.com/) that we created earlier click on \"Automated ML\" in the left menu and select the dataset you just uploaded. Click Next.\n", + "![27](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/aml-1.PNG)\n", + "\n", + "15\\. Enter a new experiment name, the target column (DEATH_EVENT) and the compute cluster we created. Click Next.\n", + "![28](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/aml-2.PNG)\n", + "\n", + "16\\. Choose \"Classification\" and Click Finish. This step might take between 30 minutes to 1 hour, depending upon your compute cluster size.\n", + "![30](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/aml-3.PNG)\n", + "\n", + "17\\. Once the run is complete, click on the \"Automated ML\" tab, click on your run, and click on the Algorithm in the \"Best model summary\" card.\n", + "![31](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/aml-4.PNG)\n", + "\n", + "Here you can see a detailed description of the best model that AutoML generated. You can also explore other modes generated in the Models tab. Take a few minutes to explore the models in the Explanations (preview button). Once you have chosen the model you want to use (here we will choose the best model selected by autoML), we will see how we can deploy it.\n", + "\n", + "## Low code/no code model deployment and endpoint consumption\n", + "\n", + "### Model deployment\n", + "\n", + "The automated Machine Learning interface allows you to deploy the best model as a web service in a few steps. Deployment is the integration of the model so that it can make predictions based on new data and identify potential areas of opportunity. For this project, deployment to a web service means that medical applications will be able to consume the model to be able to make live predictions of their patient's risk to get a heart attack.\n", + "\n", + "In the best model description, click on the \"Deploy\" button.\n", + "\n", + "![deploy-1](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deploy-1.PNG)\n", + "\n", + "18\\. Give it a name, a description, compute type (Azure Container Instance), enable authentication and click on Deploy. This step might take about 20 minutes to complete. The deployment process entails several steps including registering the model, generating resources, and configuring them for the web service. A status message appears under Deploy status. Select Refresh periodically to check the deployment status. It is deployed and running when the status is \"Healthy\".\n", + "\n", + "![deploy-2](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deploy-2.PNG)\n", + "\n", + "19\\. Once it has been deployed, click on the Endpoint tab and click on the endpoint you just deployed. You can find here all the details you need to know about the endpoint. \n", + "\n", + "![deploy-3](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/deploy-3.PNG)\n", + "\n", + "Amazing! Now that we have a model deployed, we can start the consumption of the endpoint.\n", + "\n", + "### Endpoint consumption\n", + "\n", + "Click on the \"Consume\" tab. Here you can find the REST endpoint and a python script in the consumption option. Take some time to read the python code. \n", + "\n", + "This script can be run directly from your local machine and will consume your endpoint.\n", + "\n", + "![35](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/consumption-1.PNG)\n", + "\n", + "Take a moment to check those 2 lines of code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88ad0a9c", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "url = 'http://98e3715f-xxxx-xxxx-xxxx-9ec22d57b796.centralus.azurecontainer.io/score'\n", + "api_key = '' # Replace this with the API key for the web service" + ] + }, + { + "cell_type": "markdown", + "id": "72761ffd", + "metadata": {}, + "source": [ + "The `url` variable is the REST endpoint found in the consume tab and the `api_key` variable is the primary key also found in the consume tab (only in the case you have enabled authentication). This is how the script can consume the endpoint.\n", + "\n", + "20\\. Running the script, you should see the following output:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "806ae22a", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "b'\"{\\\\\"result\\\\\": [true]}\"'" + ] + }, + { + "cell_type": "markdown", + "id": "d244da87", + "metadata": {}, + "source": [ + "This means that the prediction of heart failure for the data given is true. This makes sense because if you look more closely at the data automatically generated in the script, everything is at 0 and false by default. You can change the data with the following input sample:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e10016c", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "data = {\n", + " \"data\":\n", + " [\n", + " {\n", + " 'age': \"0\",\n", + " 'anaemia': \"false\",\n", + " 'creatinine_phosphokinase': \"0\",\n", + " 'diabetes': \"false\",\n", + " 'ejection_fraction': \"0\",\n", + " 'high_blood_pressure': \"false\",\n", + " 'platelets': \"0\",\n", + " 'serum_creatinine': \"0\",\n", + " 'serum_sodium': \"0\",\n", + " 'sex': \"false\",\n", + " 'smoking': \"false\",\n", + " 'time': \"0\",\n", + " },\n", + " {\n", + " 'age': \"60\",\n", + " 'anaemia': \"false\",\n", + " 'creatinine_phosphokinase': \"500\",\n", + " 'diabetes': \"false\",\n", + " 'ejection_fraction': \"38\",\n", + " 'high_blood_pressure': \"false\",\n", + " 'platelets': \"260000\",\n", + " 'serum_creatinine': \"1.40\",\n", + " 'serum_sodium': \"137\",\n", + " 'sex': \"false\",\n", + " 'smoking': \"false\",\n", + " 'time': \"130\",\n", + " },\n", + " ],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "cfd2909c", + "metadata": {}, + "source": [ + "The script should return :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "231ab12d", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "b'\"{\\\\\"result\\\\\": [true, false]}\"'" + ] + }, + { + "cell_type": "markdown", + "id": "467172a8", + "metadata": {}, + "source": [ + "Congratulations! You just consumed the model deployed and trained it on Azure ML!\n", + "\n", + ":::{note}\n", + "Once you are done with the project, don't forget to delete all the resources.\n", + ":::\n", + "\n", + "## Your turn! 🚀\n", + "\n", + "Look closely at the model explanations and details that AutoML generated for the top models. Try to understand why the best model is better than the other ones. What algorithms were compared? What are the differences between them? Why is the best one performing better in this case?\n", + "\n", + "Assignment - [Low code/no code Data Science project on Azure ML](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/data-science/low-code-no-code-data-science-project-on-azure-ml.md)\n", + "\n", + "## Self Study\n", + "\n", + "In this section, you learned how to train, deploy and consume a model to predict heart failure risk in a low code/no code fashion in the cloud. If you have not done it yet, dive deeper into the model explanations that AutoML generated for the top models and try to understand why the best model is better than others.\n", + "\n", + "You can go further into Low code/No code AutoML by reading this [documentation](https://docs.microsoft.com/azure/machine-learning/tutorial-first-experiment-automated-ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109).\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter.\n", + "\n", + "Data for the Heart Failure Prediction project is sourced from [Larxel](https://www.kaggle.com/andrewmvd) on [Kaggle](https://www.kaggle.com/andrewmvd/heart-failure-clinical-data). It is licensed under the [Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.md b/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.md deleted file mode 100644 index ae8b659dfd..0000000000 --- a/open-machine-learning-jupyter-book/data-science/data-science-in-the-cloud/the-low-code-no-code-way.md +++ /dev/null @@ -1,333 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: Python - name: Python3 ---- - -# The "low code/no code" way - -## What is Azure Machine Learning(ML)? - -The Azure cloud platform is more than 200 products and cloud services designed to help you bring new solutions to life. Data scientists expend a lot of effort exploring and pre-processing data and trying various types of model-training algorithms to produce accurate models. These tasks are time-consuming and often make inefficient use of expensive compute hardware. - -[Azure ML](https://docs.microsoft.com/azure/machine-learning/overview-what-is-azure-machine-learning?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) is a cloud-based platform for building and operating Machine Learning solutions in Azure. It includes a wide range of features and capabilities that help data scientists prepare data, train models, publish predictive services, and monitor their usage. Most importantly, it helps them to increase their efficiency by automating many of the time-consuming tasks associated with training models; and it enables them to use cloud-based compute resources that scale effectively, to handle large volumes of data while incurring costs only when actually used. - -Azure ML provides all the tools developers and data scientists need for their Machine Learning workflows. These include: - -- **Azure Machine Learning Studio**: it is a web portal in Azure Machine Learning for low-code and no-code options for model training, deployment, automation, tracking and asset management. The studio integrates with the Azure Machine Learning SDK for a seamless experience. -- **Jupyter Notebooks**: quickly prototype and test ML models. -- **Azure Machine Learning Designer**: allows to drag-n-drop modules to build experiments and then deploy pipelines in a low-code environment. -- **Automated Machine Learning UI (AutoML)** : automates iterative tasks of Machine Learning model development, allowing to build Machine Learning models with high scale, efficiency, and productivity, all while sustaining model quality. -- **Data Labelling**: an assisted ML tool to automatically label data. -- **Machine Learning extension for Visual Studio Code**: provides a full-featured development environment for building and managing Machine Learning projects. -- **Machine Learning CLI**: provides commands for managing Azure ML resources from the command line. -- **Integration with open-source frameworks** such as PyTorch, TensorFlow, Scikit-learn and many more for training, deploying and managing the end-to-end Machine Learning process. -- **MLflow**: It is an open-source library for managing the life cycle of your Lachine Learning experiments. **MLflow Tracking** is a component of MLflow that logs and tracks your training run metrics and model artifacts, irrespective of your experiment's environment. - -## The heart failure prediction project - -There is no doubt that making and building projects are the best way to put your skills and knowledge to the test. In this section, we are going to explore two different ways of building a data science project for the prediction of heart failure attacks in Azure ML Studio, through Low code/No code and through the Azure ML SDK as shown in the following schema: - -![project-schema](../../../images/project-schema.png) - -Each way has its own pros and cons. The Low code/No code way is easier to start with as it involves interacting with a GUI (Graphical User Interface), with no prior knowledge of code required. This method enables quick testing of the project's viability and to create POC (Proof Of Concept). However, as the project grows and things need to be production ready, it is not feasible to create resources through GUI. We need to programmatically automate everything, from the creation of resources to the deployment of a model. This is where knowing how to use the Azure ML SDK becomes crucial. - -| | Low code/no code | Azure ML SDK | -|-------------------|------------------|---------------------------| -| Expertise in code | Not required | Required | -| Time to develop | Fast and easy | Depends on code expertise | -| Production ready | No | Yes | - -## The heart failure dataset - -Cardiovascular diseases (CVDs) are the number 1 cause of death globally, accounting for 31% of all deaths worldwide. Environmental and behavioral risk factors such as use of tobacco, unhealthy diet and obesity, physical inactivity and harmful use of alcohol could be used as features for estimation models. Being able to estimate the probability of the development of a CVD could be of great use to prevent attacks in high-risk people. - -Kaggle has made a [Heart Failure dataset](https://www.kaggle.com/andrewmvd/heart-failure-clinical-data) publicly available, that we are going to use for this project. You can download the dataset now. This is a tabular dataset with 13 columns (12 features and 1 target variable) and 299 rows. - -| | Variable name | Type | Description | Example | -|----|---------------------------|-----------------|-----------------------------------------------------------|-------------------| -| 1 | age | numerical | age of the patient | 25 | -| 2 | anaemia | boolean | Decrease of red blood cells or haemoglobin | 0 or 1 | -| 3 | creatinine_phosphokinase | numerical | Level of CPK enzyme in the blood | 542 | -| 4 | diabetes | boolean | If the patient has diabetes | 0 or 1 | -| 5 | ejection_fraction | numerical | Percentage of blood leaving the heart on each contraction | 45 | -| 6 | high_blood_pressure | boolean | If the patient has hypertension | 0 or 1 | -| 7 | platelets | numerical | Platelets in the blood | 149000 | -| 8 | serum_creatinine | numerical | Level of serum creatinine in the blood | 0.5 | -| 9 | serum_sodium | numerical | Level of serum sodium in the blood | jun | -| 10 | sex | boolean | woman or man | 0 or 1 | -| 11 | smoking | boolean | If the patient smokes | 0 or 1 | -| 12 | time | numerical | follow-up period (days) | 4 | -|----|---------------------------|-----------------|-----------------------------------------------------------|-------------------| -| 21 | DEATH_EVENT [Target] | boolean | if the patient dies during the follow-up period | 0 or 1 | - -Once you have the dataset, we can start the project in Azure. - -## Low code/no code training of a model in Azure ML Studio - -### Create an Azure ML workspace - -To train a model in Azure ML you first need to create an Azure ML workspace. The workspace is the top-level resource for Azure Machine Learning, providing a centralized place to work with all the artifacts you create when you use Azure Machine Learning. The workspace keeps a history of all training runs, including logs, metrics, output, and a snapshot of your scripts. You use this information to determine which training run produces the best model. [Learn more](https://docs.microsoft.com/azure/machine-learning/concept-workspace?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). - -It is recommended to use the most up-to-date browser that's compatible with your operating system. The following browsers are supported: - -- Microsoft Edge (The new Microsoft Edge, the latest version. Not Microsoft Edge legacy) -- Safari (latest version, Mac only) -- Chrome (latest version) -- Firefox (latest version) - -To use Azure Machine Learning, create a workspace in your Azure subscription. You can then use this workspace to manage data, compute resources, code, models, and other artifacts related to your Machine Learning workloads. - -```{note} -Your Azure subscription will be charged a small amount for data storage as long as the Azure Machine Learning workspace exists in your subscription, so we recommend you to delete the Azure Machine Learning workspace when you are no longer using it. -``` - -1\. Sign in to the [Azure portal](https://ms.portal.azure.com/) using the Microsoft credentials associated with your Azure subscription. - -2\. Select **＋Create a resource**. - -![workspace-1](../../../images/workspace-1.PNG) - -Search for Machine Learning and select the Machine Learning tile. - -![workspace-2](../../../images/workspace-2.PNG) - -Click the create button. - -![workspace-3](../../../images/workspace-3.PNG) - -Fill in the settings as follows: - -- Subscription: Your Azure subscription. -- Resource group: Create or select a resource group. -- Workspace name: Enter a unique name for your workspace. -- Region: Select the geographical region closest to you. -- Storage account: Note the default new storage account that will be created for your workspace. -- Key vault: Note the default new key vault that will be created for your workspace. -- Application insights: Note the default new application insights resource that will be created for your workspace. -- Container registry: None (one will be created automatically the first time you deploy a model to a container) - ![workspace-4](../../../images/workspace-4.PNG). -- Click the create + review and then on the create button. - -3\. Wait for your workspace to be created (this can take a few minutes). Then go to it in the portal. You can find it through the Machine Learning Azure service. - -4\. On the Overview page for your workspace, launch Azure Machine Learning studio (or open a new browser tab and navigate to [Azure ML](https://ml.azure.com), and sign into Azure Machine Learning studio using your Microsoft account. If prompted, select your Azure directory and subscription, and your Azure Machine Learning workspace. - -![workspace-5](../../../images/workspace-5.PNG) - -5\. In Azure Machine Learning Studio, toggle the ☰ icon at the top left to view the various pages in the interface. You can use these pages to manage the resources in your workspace. - -![workspace-6](../../../images/workspace-6.PNG) - -You can manage your workspace using the Azure portal, but for data scientists and Machine Learning operations engineers, Azure Machine Learning Studio provides a more focused user interface for managing workspace resources. - -### Compute resources - -Compute Resources are cloud-based resources on which you can run model training and data exploration processes. There are four kinds of compute resource you can create: - -- **Compute Instances**: Development workstations that data scientists can use to work with data and models. This involves the creation of a Virtual Machine (VM) and launching a notebook instance. You can then train a model by calling a computer cluster from the notebook. -- **Compute Clusters**: Scalable clusters of VMs for on-demand processing of experiment code. You will need it when training a model. Compute clusters can also employ specialized GPU or CPU resources. -- **Inference Clusters**: Deployment targets for predictive services that use your trained models. -- **Attached Compute**: Links to existing Azure compute resources, such as Virtual Machines or Azure Databricks clusters. - -### Choosing the right options for your compute resources - -Some key factors are to consider when creating a compute resource and those choices can be critical decisions to make. - -**Do you need CPU or GPU?** - -A CPU (Central Processing Unit) is the electronic circuitry that executes instructions comprising a computer program. A GPU (Graphics Processing Unit) is a specialized electronic circuit that can execute graphics-related code at a very high rate. - -The main difference between CPU and GPU architecture is that a CPU is designed to handle a wide-range of tasks quickly (as measured by CPU clock speed), but are limited in the concurrency of tasks that can be running. GPUs are designed for parallel computing and therefore are much better at deep learning tasks. - -| CPU | GPU | -|-----------------------------------------|-----------------------------| -| Less expensive | More expensive | -| Lower level of concurrency | Higher level of concurrency | -| Slower in training deep learning models | Optimal for deep learning | - -**Cluster size** - -Larger clusters are more expensive but will result in better responsiveness. Therefore, if you have time but not enough money, you should start with a small cluster. Conversely, if you have money but not much time, you should start with a larger cluster. - -**VM size** - -Depending on your time and budgetary constraints, you can vary the size of your RAM, disk, number of cores and clock speed. Increasing all those parameters will be costlier, but will result in better performance. - -**Dedicated or low-priority instances?** - -A low-priority instance means that it is interruptible: essentially, Microsoft Azure can take those resources and assign them to another task, thus interrupting a job. A dedicated instance, or non-interruptible, means that the job will never be terminated without your permission. -This is another consideration of time vs money, since interruptible instances are less expensive than dedicated ones. - -### Creating a compute cluster - -In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, go to compute and you will be able to see the different compute resources we just discussed (i.e compute instances, compute clusters, inference clusters and attached compute). For this project, we are going to need a compute cluster for model training. In the Studio, Click on the "Compute" menu, then the "Compute cluster" tab and click on the "+ New" button to create a compute cluster. - -![22](../../../images/cluster-1.PNG) - -6\. Choose your options: Dedicated vs Low priority, CPU or GPU, VM size and core number (you can keep the default settings for this project). - -7\. Click on the Next button. - -![23](../../../images/cluster-2.PNG) - -8\. Give the cluster a compute name - -9\. Choose your options: Minimum/Maximum number of nodes, Idle seconds before scale down, SSH access. Note that if the minimum number of nodes is 0, you will save money when the cluster is idle. Note that the higher the number of maximum nodes, the shorter the training will be. The maximum number of nodes recommended is 3. - -10\. Click on the "Create" button. This step may take a few minutes. -![29](../../../images/cluster-3.PNG) - -Awesome! Now that we have a Compute cluster, we need to load the data to Azure ML Studio. - -### Loading the dataset - -11\. In the [Azure ML workspace](https://ml.azure.com/) that we created earlier, click on "Datasets" in the left menu and click on the "+ Create dataset" button to create a dataset. Choose the "From local files" option and select the Kaggle dataset we downloaded earlier. -![24](../../../images/dataset-1.PNG) - -12\. Give your dataset a name, a type and a description. Click Next. Upload the data from files. Click Next. -![25](../../../images/dataset-2.PNG) - -13\. In the Schema, change the data type to Boolean for the following features: anemia, diabetes, high blood pressure, sex, smoking, and DEATH_EVENT. Click Next and Click Create. -![26](../../../images/dataset-3.PNG) - -Great! Now that the dataset is in place and the compute cluster is created, we can start the training of the model! - -## Low code/no code training with AutoML - -Traditional Machine Learning model development is resource-intensive, requires significant domain knowledge and time to produce and compare dozens of models. -Automated Machine Learning (AutoML), is the process of automating the time-consuming, iterative tasks of Machine Learning model development. It allows data scientists, analysts, and developers to build ML models with high scale, efficiency, and productivity, all while sustaining model quality. It reduces the time it takes to get production-ready ML models, with great ease and efficiency. [Learn more](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109) - -14\. In the [Azure ML workspace](https://ml.azure.com/) that we created earlier click on "Automated ML" in the left menu and select the dataset you just uploaded. Click Next. -![27](../../../images/aml-1.PNG) - -15\. Enter a new experiment name, the target column (DEATH_EVENT) and the compute cluster we created. Click Next. -![28](../../../images/aml-2.PNG) - -16\. Choose "Classification" and Click Finish. This step might take between 30 minutes to 1 hour, depending upon your compute cluster size. -![30](../../../images/aml-3.PNG) - -17\. Once the run is complete, click on the "Automated ML" tab, click on your run, and click on the Algorithm in the "Best model summary" card. -![31](../../../images/aml-4.PNG) - -Here you can see a detailed description of the best model that AutoML generated. You can also explore other modes generated in the Models tab. Take a few minutes to explore the models in the Explanations (preview button). Once you have chosen the model you want to use (here we will choose the best model selected by autoML), we will see how we can deploy it. - -## Low code/no code model deployment and endpoint consumption - -### Model deployment - -The automated Machine Learning interface allows you to deploy the best model as a web service in a few steps. Deployment is the integration of the model so that it can make predictions based on new data and identify potential areas of opportunity. For this project, deployment to a web service means that medical applications will be able to consume the model to be able to make live predictions of their patient's risk to get a heart attack. - -In the best model description, click on the "Deploy" button. - -![deploy-1](../../../images/deploy-1.PNG) - -18\. Give it a name, a description, compute type (Azure Container Instance), enable authentication and click on Deploy. This step might take about 20 minutes to complete. The deployment process entails several steps including registering the model, generating resources, and configuring them for the web service. A status message appears under Deploy status. Select Refresh periodically to check the deployment status. It is deployed and running when the status is "Healthy". - -![deploy-2](../../../images/deploy-2.PNG) - -19\. Once it has been deployed, click on the Endpoint tab and click on the endpoint you just deployed. You can find here all the details you need to know about the endpoint. - -![deploy-3](../../../images/deploy-3.PNG) - -Amazing! Now that we have a model deployed, we can start the consumption of the endpoint. - -### Endpoint consumption - -Click on the "Consume" tab. Here you can find the REST endpoint and a python script in the consumption option. Take some time to read the python code. - -This script can be run directly from your local machine and will consume your endpoint. - -![35](../../../images/consumption-1.PNG) - -Take a moment to check those 2 lines of code: - -```python -url = 'http://98e3715f-xxxx-xxxx-xxxx-9ec22d57b796.centralus.azurecontainer.io/score' -api_key = '' # Replace this with the API key for the web service -``` - -The `url` variable is the REST endpoint found in the consume tab and the `api_key` variable is the primary key also found in the consume tab (only in the case you have enabled authentication). This is how the script can consume the endpoint. - -20\. Running the script, you should see the following output: - -```python -b'"{\\"result\\": [true]}"' -``` - -This means that the prediction of heart failure for the data given is true. This makes sense because if you look more closely at the data automatically generated in the script, everything is at 0 and false by default. You can change the data with the following input sample: - -```python -data = { - "data": - [ - { - 'age': "0", - 'anaemia': "false", - 'creatinine_phosphokinase': "0", - 'diabetes': "false", - 'ejection_fraction': "0", - 'high_blood_pressure': "false", - 'platelets': "0", - 'serum_creatinine': "0", - 'serum_sodium': "0", - 'sex': "false", - 'smoking': "false", - 'time': "0", - }, - { - 'age': "60", - 'anaemia': "false", - 'creatinine_phosphokinase': "500", - 'diabetes': "false", - 'ejection_fraction': "38", - 'high_blood_pressure': "false", - 'platelets': "260000", - 'serum_creatinine': "1.40", - 'serum_sodium': "137", - 'sex': "false", - 'smoking': "false", - 'time': "130", - }, - ], -} -``` - -The script should return : - -```python -b'"{\\"result\\": [true, false]}"' -``` - -Congratulations! You just consumed the model deployed and trained it on Azure ML! - -```{note} -Once you are done with the project, don't forget to delete all the resources. -``` - -## Your turn! 🚀 - -Look closely at the model explanations and details that AutoML generated for the top models. Try to understand why the best model is better than the other ones. What algorithms were compared? What are the differences between them? Why is the best one performing better in this case? - -Assignment - [Low code/no code Data Science project on Azure ML](../../assignments/data-science/low-code-no-code-data-science-project-on-azure-ml.md) - -## Self Study - -In this section, you learned how to train, deploy and consume a model to predict heart failure risk in a low code/no code fashion in the cloud. If you have not done it yet, dive deeper into the model explanations that AutoML generated for the top models and try to understand why the best model is better than others. - -You can go further into Low code/No code AutoML by reading this [documentation](https://docs.microsoft.com/azure/machine-learning/tutorial-first-experiment-automated-ml?WT.mc_id=academic-77958-bethanycheum&ocid=AID3041109). - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [Data Science for Beginners](https://github.com/microsoft/Data-Science-For-Beginners). It inspires the majority of the content in this chapter. - -Data for the Heart Failure Prediction project is sourced from [Larxel](https://www.kaggle.com/andrewmvd) on [Kaggle](https://www.kaggle.com/andrewmvd/heart-failure-clinical-data). It is licensed under the [Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) diff --git a/open-machine-learning-jupyter-book/ml-advanced/kernel-method.md b/open-machine-learning-jupyter-book/ml-advanced/kernel-method.md index 040fbf6995..f487b1d70b 100644 --- a/open-machine-learning-jupyter-book/ml-advanced/kernel-method.md +++ b/open-machine-learning-jupyter-book/ml-advanced/kernel-method.md @@ -340,4 +340,9 @@ A demo of SVM. [source]< A demo of SVM. [source] -

\ No newline at end of file +

+ + + +## Your turn! 🚀 +You can follow this [assignment](../assignments/ml-advanced/kernel-method/kernel-method-assignment-1.ipynb) to practise Support Vector Machines with examples. diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.ipynb new file mode 100644 index 0000000000..d06c4c06a0 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.ipynb @@ -0,0 +1,88 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys \n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\n", + "\n", + "# Applied Machine Learning : build a web app\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.md b/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.md deleted file mode 100644 index 97cf6c7306..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/classification/applied-ml-build-a-web-app.md +++ /dev/null @@ -1,16 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Applied Machine Learning : build a web app diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.ipynb new file mode 100644 index 0000000000..5c1153e478 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.ipynb @@ -0,0 +1,94 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys \n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting started with classification\n", + "\n", + "In Asia and India, food traditions are extremely diverse, and very delicious! Let's look at data about regional cuisines to try to understand their ingredients.\n", + "\n", + "![Thai food seller](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/thai-food.jpg)\n", + "> Photo by Lisheng Chang on Unsplash\n", + "\n", + "In this section, you will build on your earlier study of Regression and learn about other classifiers that you can use to better understand the data.\n", + "\n", + ":::{seealso}\n", + "There are useful low-code tools that can help you learn about working with classification models. Try [Azure ML for this task](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)\n", + ":::\n", + "\n", + "\n", + "---" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.md b/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.md deleted file mode 100644 index 91c2110cd1..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/classification/getting-started-with-classification.md +++ /dev/null @@ -1,37 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Getting started with classification - -In Asia and India, food traditions are extremely diverse, and very delicious! Let's look at data about regional cuisines to try to understand their ingredients. - -```{figure} ../../../images/ml-fundamentals/ml-classification/thai-food.jpg ---- -name: 'Thai food seller' -width: 90% ---- -Photo by Lisheng Chang on Unsplash -``` - -In this section, you will build on your earlier study of Regression and learn about other classifiers that you can use to better understand the data. - -```{seealso} -There are useful low-code tools that can help you learn about working with classification models. Try [Azure ML for this task](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott) -``` - ---- - -```{tableofcontents} -``` diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.ipynb new file mode 100644 index 0000000000..0ba8cbc3b9 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.ipynb @@ -0,0 +1,1447 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f1464d3f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "848fcc94-3480-439c-b565-b8dc6072268a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys \n", + "!{sys.executable} -m pip install --quiet pandas numpy matplotlib jupyterlab_myst ipython imblearn\n" + ] + }, + { + "cell_type": "markdown", + "id": "b0926c24", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\n", + "# Introduction to classification\n", + "\n", + "In these four sections, you will explore a fundamental focus of classic machine learning _classification_. We will walk through using various classification algorithms with a dataset about all the brilliant cuisines of Asia and India. Hope you're hungry!" + ] + }, + { + "cell_type": "markdown", + "id": "4cc6fb13", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/pinch.png\n", + "---\n", + "name: 'Celebrate pan-Asian cuisines in these lessons!'\n", + "width: 90%\n", + "---\n", + "Image by [Jen Looper](https://twitter.com/jenlooper)\n", + ":::" + ] + }, + { + "cell_type": "markdown", + "id": "21bdf1d7", + "metadata": {}, + "source": [ + "Classification is a form of [supervised learning](https://wikipedia.org/wiki/Supervised_learning) that bears a lot in common with regression techniques. If machine learning is all about predicting values or names to things by using datasets, then classification generally falls into two groups: _binary classification_ and _multiclass classification_." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4b39b77c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "output-scoll" + ] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + "
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import HTML\n", + "\n", + "display(\n", + " HTML(\n", + " \"\"\"\n", + "
\n", + " \n", + "
\n", + "\"\"\"\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ebd13d4a", + "metadata": {}, + "source": [ + "Click the video above for a quick introduction to classification." + ] + }, + { + "cell_type": "markdown", + "id": "a446aae1", + "metadata": {}, + "source": [ + ":::{note}\n", + "- **Linear regression** helped you predict relationships between variables and make accurate predictions on where a new datapoint would fall in relationship to that line. So, you could predict _what price a pumpkin would be in September vs. December_, for example.\n", + "- **Logistic regression** helped you discover \"binary categories\": at this price point, _is this pumpkin orange or not-orange_?\n", + "\n", + "Classification uses various algorithms to determine other ways of determining a data point's label or class. Let's work with this cuisine data to see whether, by observing a group of ingredients, we can determine its cuisine of origin.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dad60c56", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "output-scoll" + ] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "

\n", + "\n", + "A demo of Neural Network Playground. [source]\n", + "

\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import HTML\n", + "\n", + "display(\n", + " HTML(\n", + " \"\"\"\n", + "

\n", + "\n", + "A demo of Neural Network Playground. [source]\n", + "

\n", + "\"\"\"\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "44c95f32", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "Classification is one of the fundamental activities of the machine learning researcher and data scientist. From basic classification of a binary value (\"is this email spam or not?\"), to complex image classification and segmentation using computer vision, it's always useful to be able to sort data into classes and ask questions of it.\n", + "\n", + "To state the process in a more scientific way, your classification method creates a predictive model that enables you to map the relationship between input variables to output variables.\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/binary-multiclass.png\n", + "---\n", + "name: 'binary vs. multiclass classification'\n", + "width: 90%\n", + "---\n", + "Infographic by [Jen Looper](https://twitter.com/jenlooper)\n", + ":::\n" + ] + }, + { + "cell_type": "markdown", + "id": "752b6fbd", + "metadata": {}, + "source": [ + "Before starting the process of cleaning our data, visualizing it, and prepping it for our ML tasks, let's learn a bit about the various ways machine learning can be leveraged to classify data.\n", + "\n", + "Derived from [statistics](https://wikipedia.org/wiki/Statistical_classification), classification using classic machine learning uses features, such as `smoker`, `weight`, and `age` to determine _likelihood of developing X disease_. As a supervised learning technique similar to the regression exercises you performed earlier, your data is labeled and the ML algorithms use those labels to classify and predict classes (or 'features') of a dataset and assign them to a group or outcome.\n", + "\n", + ":::{note}\n", + "Take a moment to imagine a dataset about cuisines. What would a multiclass model be able to answer? What would a binary model be able to answer? What if you wanted to determine whether a given cuisine was likely to use fenugreek? What if you wanted to see if, given a present of a grocery bag full of star anise, artichokes, cauliflower, and horseradish, you could create a typical Indian dish?\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f7f31899", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input", + "output-scoll" + ] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + "
\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import HTML\n", + "\n", + "display(\n", + " HTML(\n", + " \"\"\"\n", + "
\n", + " \n", + "
\n", + "\n", + "\"\"\"\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4084b626", + "metadata": {}, + "source": [ + "Click the video above. The whole premise of the show 'Chopped' is the 'mystery basket' where chefs have to make some dish out of a random choice of ingredients. Surely a ML model would have helped!" + ] + }, + { + "cell_type": "markdown", + "id": "d5416a55", + "metadata": {}, + "source": [ + "## Hello 'classifier'\n", + "\n", + "The question we want to ask of this cuisine dataset is actually a **multiclass question**, as we have several potential national cuisines to work with. Given a batch of ingredients, which of these many classes will the data fit?\n", + "\n", + "Scikit-learn offers several different algorithms to use to classify data, depending on the kind of problem you want to solve. In the next two sections, you'll learn about several of these algorithms.\n", + "\n", + "## Exercise - clean and balance your data\n", + "\n", + "The first task at hand, before starting this project, is to clean and **balance** your data to get better results. Start with the blank [delicious-asian-and-indian-cuisines.ipynb](../../assignments/ml-fundamentals/delicious-asian-and-indian-cuisines.ipynb) file.\n", + "\n", + "The first thing to install is [imblearn](https://imbalanced-learn.org/stable/). This is a Scikit-learn package that will allow you to better balance the data (you will learn more about this task in a minute).\n", + "\n", + "1\\. Import the packages you need to import your data and visualize it, also import `SMOTE` from `imblearn`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1c741afb", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + }, + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import numpy as np\n", + "from imblearn.over_sampling import SMOTE" + ] + }, + { + "cell_type": "markdown", + "id": "2f85a608", + "metadata": {}, + "source": [ + "Now you are set up to read import the data next.\n", + "\n", + "2\\. The next task will be to import the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0bafb815", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + }, + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "df = pd.read_csv('https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/classification/cuisines.csv')" + ] + }, + { + "cell_type": "markdown", + "id": "fc4a461f", + "metadata": {}, + "source": [ + "Using `read_csv()` will read the content of the csv file _cusines.csv_ and place it in the variable `df`.\n", + "\n", + "3\\. Check the data's shape:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "daaea537", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0cuisinealmondangelicaaniseanise_seedappleapple_brandyapricotarmagnac...whiskeywhite_breadwhite_winewhole_grain_wheat_flourwinewoodyamyeastyogurtzucchini
065indian00000000...0000000000
166indian10000000...0000000000
267indian00000000...0000000000
368indian00000000...0000000000
469indian00000000...0000000010
\n", + "

5 rows × 385 columns

\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n", + "0 65 indian 0 0 0 0 0 \n", + "1 66 indian 1 0 0 0 0 \n", + "2 67 indian 0 0 0 0 0 \n", + "3 68 indian 0 0 0 0 0 \n", + "4 69 indian 0 0 0 0 0 \n", + "\n", + " apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n", + "0 0 0 0 ... 0 0 0 \n", + "1 0 0 0 ... 0 0 0 \n", + "2 0 0 0 ... 0 0 0 \n", + "3 0 0 0 ... 0 0 0 \n", + "4 0 0 0 ... 0 0 0 \n", + "\n", + " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n", + "0 0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 1 0 \n", + "\n", + "[5 rows x 385 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "45937a40", + "metadata": {}, + "source": [ + "The first five rows look like this.\n", + "\n", + "4\\. Get info about this data by calling `info()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "be437736", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 2448 entries, 0 to 2447\n", + "Columns: 385 entries, Unnamed: 0 to zucchini\n", + "dtypes: int64(384), object(1)\n", + "memory usage: 7.2+ MB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "markdown", + "id": "7153e091", + "metadata": {}, + "source": [ + "## Exercise - learning about cuisines\n", + "\n", + "Now the work starts to become more interesting. Let's discover the distribution of data, per cuisine \n", + "\n", + "1\\. Plot the data as bars by calling `barh()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bb5e5bb0", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.cuisine.value_counts().plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "5ee9945a", + "metadata": {}, + "source": [ + "There are a finite number of cuisines, but the distribution of data is uneven. You can fix that! Before doing so, explore a little more. \n", + "\n", + "2\\. Find out how much data is available per cuisine and print it out:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d40979db", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + }, + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thai df: (289, 385)\n", + "japanese df: (320, 385)\n", + "chinese df: (442, 385)\n", + "indian df: (598, 385)\n", + "korean df: (799, 385)\n" + ] + } + ], + "source": [ + "thai_df = df[(df.cuisine == \"thai\")]\n", + "japanese_df = df[(df.cuisine == \"japanese\")]\n", + "chinese_df = df[(df.cuisine == \"chinese\")]\n", + "indian_df = df[(df.cuisine == \"indian\")]\n", + "korean_df = df[(df.cuisine == \"korean\")]\n", + "\n", + "print(f'thai df: {thai_df.shape}')\n", + "print(f'japanese df: {japanese_df.shape}')\n", + "print(f'chinese df: {chinese_df.shape}')\n", + "print(f'indian df: {indian_df.shape}')\n", + "print(f'korean df: {korean_df.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "7b170b33", + "metadata": {}, + "source": [ + "## Discovering ingredients\n", + "\n", + "Now you can dig deeper into the data and learn what are the typical ingredients per cuisine. You should clean out recurrent data that creates confusion between cuisines, so let's learn about this problem.\n", + "\n", + "1\\. Create a function `create_ingredient()` in Python to create an ingredient dataframe. This function will start by dropping an unhelpful column and sort through ingredients by their count:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7c5efc6a", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "def create_ingredient_df(df):\n", + " ingredient_df = df.T.drop(['cuisine' ,'Unnamed: 0']).sum(axis=1).to_frame('value')\n", + " ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]\n", + " ingredient_df = ingredient_df.sort_values(by='value' , ascending=False,\n", + " inplace=False)\n", + " return ingredient_df" + ] + }, + { + "cell_type": "markdown", + "id": "33597941", + "metadata": {}, + "source": [ + "Now you can use that function to get an idea of top ten most popular ingredients by cuisine.\n", + "\n", + "2\\. Call `create_ingredient()` and plot it calling `barh()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f104824d", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "thai_ingredient_df = create_ingredient_df(thai_df)\n", + "thai_ingredient_df.head(10).plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "be069706", + "metadata": {}, + "source": [ + "3\\. Do the same for the japanese data:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a446b357", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "japanese_ingredient_df = create_ingredient_df(japanese_df)\n", + "japanese_ingredient_df.head(10).plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "4079ce7b", + "metadata": {}, + "source": [ + "4\\. Now for the chinese ingredients:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b329dcf0", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "chinese_ingredient_df = create_ingredient_df(chinese_df)\n", + "chinese_ingredient_df.head(10).plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "cdb719a9", + "metadata": {}, + "source": [ + "5\\. Plot the indian ingredients:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "37e0e248", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "indian_ingredient_df = create_ingredient_df(indian_df)\n", + "indian_ingredient_df.head(10).plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "bdc62a68", + "metadata": {}, + "source": [ + "6\\. Finally, plot the korean ingredients:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "30d6dab6", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "korean_ingredient_df = create_ingredient_df(korean_df)\n", + "korean_ingredient_df.head(10).plot.barh()" + ] + }, + { + "cell_type": "markdown", + "id": "36c313a5", + "metadata": {}, + "source": [ + "7\\. Now, drop the most common ingredients that create confusion between distinct cuisines, by calling `drop()`:\n", + "\n", + "Everyone loves rice, garlic and ginger!" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "69c3d441", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
almondangelicaaniseanise_seedappleapple_brandyapricotarmagnacartemisiaartichoke...whiskeywhite_breadwhite_winewhole_grain_wheat_flourwinewoodyamyeastyogurtzucchini
00000000000...0000000000
11000000000...0000000000
20000000000...0000000000
30000000000...0000000000
40000000000...0000000010
\n", + "

5 rows × 380 columns

\n", + "
" + ], + "text/plain": [ + " almond angelica anise anise_seed apple apple_brandy apricot \\\n", + "0 0 0 0 0 0 0 0 \n", + "1 1 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 0 0 \n", + "\n", + " armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n", + "0 0 0 0 ... 0 0 0 \n", + "1 0 0 0 ... 0 0 0 \n", + "2 0 0 0 ... 0 0 0 \n", + "3 0 0 0 ... 0 0 0 \n", + "4 0 0 0 ... 0 0 0 \n", + "\n", + " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n", + "0 0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 1 0 \n", + "\n", + "[5 rows x 380 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feature_df= df.drop(['cuisine' ,'Unnamed: 0' ,'rice' ,'garlic' ,'ginger'] , axis=1)\n", + "labels_df = df.cuisine #.unique()\n", + "feature_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "873e853e", + "metadata": {}, + "source": [ + "## Balance the dataset\n", + "\n", + "Now that you have cleaned the data, use [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - \"Synthetic Minority Over-sampling Technique\" - to balance it.\n", + "\n", + "1\\. Call `fit_resample()`, this strategy generates new samples by interpolation." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "c2b45ece", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "oversample = SMOTE()\n", + "transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)" + ] + }, + { + "cell_type": "markdown", + "id": "d945acff", + "metadata": {}, + "source": [ + "By balancing your data, you'll have better results when classifying it. Think about a binary classification. If most of your data is one class, a ML model is going to predict that class more frequently, just because there is more data for it. Balancing the data takes any skewed data and helps remove this imbalance. \n", + "\n", + "2\\. Now you can check the numbers of labels per ingredient:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "77e0437e", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "new label count: indian 799\n", + "thai 799\n", + "chinese 799\n", + "japanese 799\n", + "korean 799\n", + "Name: cuisine, dtype: int64\n", + "old label count: korean 799\n", + "indian 598\n", + "chinese 442\n", + "japanese 320\n", + "thai 289\n", + "Name: cuisine, dtype: int64\n" + ] + } + ], + "source": [ + "print(f'new label count: {transformed_label_df.value_counts()}')\n", + "print(f'old label count: {df.cuisine.value_counts()}')" + ] + }, + { + "cell_type": "markdown", + "id": "1cce2396", + "metadata": {}, + "source": [ + "The data is nice and clean, balanced, and very delicious!\n", + "\n", + "3\\. The last step is to save your balanced data, including labels and features, into a new dataframe that can be exported into a file:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "cd8e6186", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + } + }, + "outputs": [], + "source": [ + "transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')" + ] + }, + { + "cell_type": "markdown", + "id": "b55e246f", + "metadata": {}, + "source": [ + "4\\. You can take one more look at the data using `transformed_df.head()` and `transformed_df.info()`. Save a copy of this data for use in future sections:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "eafdd7e8", + "metadata": { + "attributes": { + "classes": [ + "code-cell" + ], + "id": "" + }, + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 3995 entries, 0 to 3994\n", + "Columns: 381 entries, cuisine to zucchini\n", + "dtypes: int64(380), object(1)\n", + "memory usage: 11.6+ MB\n" + ] + } + ], + "source": [ + "transformed_df.head()\n", + "transformed_df.info()\n", + "transformed_df.to_csv(\"https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/cleaned_cuisines.csv \")" + ] + }, + { + "cell_type": "markdown", + "id": "c83784b1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "---\n", + "\n", + "## Self study\n", + "\n", + "This curriculum contains several interesting datasets. Dig through the [/data/classification](https://github.com/YinYi000/machine-learning/tree/main/open-machine-learning-jupyter-book/assets/data) folders and see if any contain datasets that would be appropriate for binary or multi-class classification? What questions would you ask of this dataset?\n", + "\n", + "## Your turn! 🚀\n", + "\n", + "Explore SMOTE's API. What use cases is it best used for? What problems does it solve?\n", + "\n", + "Assignment - [Explore classification methods](../../assignments/ml-fundamentals/explore-classification-methods.md)\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.md b/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.md deleted file mode 100644 index 58f3c972b1..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/classification/introduction-to-classification.md +++ /dev/null @@ -1,272 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Introduction to classification - -In these four sections, you will explore a fundamental focus of classic machine learning _classification_. We will walk through using various classification algorithms with a dataset about all the brilliant cuisines of Asia and India. Hope you're hungry! - -```{figure} ../../../images/ml-fundamentals/ml-classification/pinch.png ---- -name: 'Celebrate pan-Asian cuisines in these lessons!' -width: 90% ---- -Image by [Jen Looper](https://twitter.com/jenlooper) -``` - -Classification is a form of [supervised learning](https://wikipedia.org/wiki/Supervised_learning) that bears a lot in common with regression techniques. If machine learning is all about predicting values or names to things by using datasets, then classification generally falls into two groups: _binary classification_ and _multiclass classification_. - -```{seealso} - -
- -
- -Click the video above for a quick introduction to classification. -``` - -```{note} -- **Linear regression** helped you predict relationships between variables and make accurate predictions on where a new datapoint would fall in relationship to that line. So, you could predict _what price a pumpkin would be in September vs. December_, for example. -- **Logistic regression** helped you discover "binary categories": at this price point, _is this pumpkin orange or not-orange_? - -Classification uses various algorithms to determine other ways of determining a data point's label or class. Let's work with this cuisine data to see whether, by observing a group of ingredients, we can determine its cuisine of origin. -``` - -

- -A demo of Neural Network Playground. [source] -

- -## Introduction - -Classification is one of the fundamental activities of the machine learning researcher and data scientist. From basic classification of a binary value ("is this email spam or not?"), to complex image classification and segmentation using computer vision, it's always useful to be able to sort data into classes and ask questions of it. - -To state the process in a more scientific way, your classification method creates a predictive model that enables you to map the relationship between input variables to output variables. - -```{figure} ../../../images/ml-fundamentals/ml-classification/binary-multiclass.png ---- -name: 'binary vs. multiclass classification' -width: 90% ---- -Infographic by [Jen Looper](https://twitter.com/jenlooper) -``` - -Before starting the process of cleaning our data, visualizing it, and prepping it for our ML tasks, let's learn a bit about the various ways machine learning can be leveraged to classify data. - -Derived from [statistics](https://wikipedia.org/wiki/Statistical_classification), classification using classic machine learning uses features, such as `smoker`, `weight`, and `age` to determine _likelihood of developing X disease_. As a supervised learning technique similar to the regression exercises you performed earlier, your data is labeled and the ML algorithms use those labels to classify and predict classes (or 'features') of a dataset and assign them to a group or outcome. - -```{note} -Take a moment to imagine a dataset about cuisines. What would a multiclass model be able to answer? What would a binary model be able to answer? What if you wanted to determine whether a given cuisine was likely to use fenugreek? What if you wanted to see if, given a present of a grocery bag full of star anise, artichokes, cauliflower, and horseradish, you could create a typical Indian dish? -``` - -```{seealso} - -
- -
- -Click the video above. The whole premise of the show 'Chopped' is the 'mystery basket' where chefs have to make some dish out of a random choice of ingredients. Surely a ML model would have helped! -``` - -## Hello 'classifier' - -The question we want to ask of this cuisine dataset is actually a **multiclass question**, as we have several potential national cuisines to work with. Given a batch of ingredients, which of these many classes will the data fit? - -Scikit-learn offers several different algorithms to use to classify data, depending on the kind of problem you want to solve. In the next two sections, you'll learn about several of these algorithms. - -## Exercise - clean and balance your data - -The first task at hand, before starting this project, is to clean and **balance** your data to get better results. Start with the blank [delicious-asian-and-indian-cuisines.ipynb](../../assignments/ml-fundamentals/delicious-asian-and-indian-cuisines.ipynb) file. - -The first thing to install is [imblearn](https://imbalanced-learn.org/stable/). This is a Scikit-learn package that will allow you to better balance the data (you will learn more about this task in a minute). - -1\. Import the packages you need to import your data and visualize it, also import `SMOTE` from `imblearn`. - -```{code-cell} -import pandas as pd -import matplotlib.pyplot as plt -import matplotlib as mpl -import numpy as np -from imblearn.over_sampling import SMOTE -``` - -Now you are set up to read import the data next. - -2\. The next task will be to import the data: - -```{code-cell} -df = pd.read_csv('../../assets/data/classification/cuisines.csv') -``` - -Using `read_csv()` will read the content of the csv file _cusines.csv_ and place it in the variable `df`. - -3\. Check the data's shape: - -```{code-cell} -:tags: [output_scroll] - -df.head() -``` - -The first five rows look like this. - -4\. Get info about this data by calling `info()`: - -```{code-cell} -df.info() -``` - -## Exercise - learning about cuisines - -Now the work starts to become more interesting. Let's discover the distribution of data, per cuisine - -1\. Plot the data as bars by calling `barh()`: - -```{code-cell} -df.cuisine.value_counts().plot.barh() -``` - -There are a finite number of cuisines, but the distribution of data is uneven. You can fix that! Before doing so, explore a little more. - -2\. Find out how much data is available per cuisine and print it out: - -```{code-cell} -thai_df = df[(df.cuisine == "thai")] -japanese_df = df[(df.cuisine == "japanese")] -chinese_df = df[(df.cuisine == "chinese")] -indian_df = df[(df.cuisine == "indian")] -korean_df = df[(df.cuisine == "korean")] - -print(f'thai df: {thai_df.shape}') -print(f'japanese df: {japanese_df.shape}') -print(f'chinese df: {chinese_df.shape}') -print(f'indian df: {indian_df.shape}') -print(f'korean df: {korean_df.shape}') -``` - -## Discovering ingredients - -Now you can dig deeper into the data and learn what are the typical ingredients per cuisine. You should clean out recurrent data that creates confusion between cuisines, so let's learn about this problem. - -1\. Create a function `create_ingredient()` in Python to create an ingredient dataframe. This function will start by dropping an unhelpful column and sort through ingredients by their count: - -```{code-cell} -def create_ingredient_df(df): - ingredient_df = df.T.drop(['cuisine' ,'Unnamed: 0']).sum(axis=1).to_frame('value') - ingredient_df = ingredient_df[(ingredient_df.T != 0).any()] - ingredient_df = ingredient_df.sort_values(by='value' , ascending=False, - inplace=False) - return ingredient_df -``` - -Now you can use that function to get an idea of top ten most popular ingredients by cuisine. - -2\. Call `create_ingredient()` and plot it calling `barh()`: - -```{code-cell} -thai_ingredient_df = create_ingredient_df(thai_df) -thai_ingredient_df.head(10).plot.barh() -``` - -3\. Do the same for the japanese data: - -```{code-cell} -japanese_ingredient_df = create_ingredient_df(japanese_df) -japanese_ingredient_df.head(10).plot.barh() -``` - -4\. Now for the chinese ingredients: - -```{code-cell} -chinese_ingredient_df = create_ingredient_df(chinese_df) -chinese_ingredient_df.head(10).plot.barh() -``` - -5\. Plot the indian ingredients: - -```{code-cell} -indian_ingredient_df = create_ingredient_df(indian_df) -indian_ingredient_df.head(10).plot.barh() -``` - -6\. Finally, plot the korean ingredients: - -```{code-cell} -korean_ingredient_df = create_ingredient_df(korean_df) -korean_ingredient_df.head(10).plot.barh() -``` - -7\. Now, drop the most common ingredients that create confusion between distinct cuisines, by calling `drop()`: - -Everyone loves rice, garlic and ginger! - -```{code-cell} -:tags: [output_scroll] - -feature_df= df.drop(['cuisine' ,'Unnamed: 0' ,'rice' ,'garlic' ,'ginger'] , axis=1) -labels_df = df.cuisine #.unique() -feature_df.head() -``` - -## Balance the dataset - -Now that you have cleaned the data, use [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Synthetic Minority Over-sampling Technique" - to balance it. - -1\. Call `fit_resample()`, this strategy generates new samples by interpolation. - -```{code-cell} -oversample = SMOTE() -transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df) -``` - -By balancing your data, you'll have better results when classifying it. Think about a binary classification. If most of your data is one class, a ML model is going to predict that class more frequently, just because there is more data for it. Balancing the data takes any skewed data and helps remove this imbalance. - -2\. Now you can check the numbers of labels per ingredient: - -```{code-cell} -print(f'new label count: {transformed_label_df.value_counts()}') -print(f'old label count: {df.cuisine.value_counts()}') -``` - -The data is nice and clean, balanced, and very delicious! - -3\. The last step is to save your balanced data, including labels and features, into a new dataframe that can be exported into a file: - -```{code-cell} -transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer') -``` - -4\. You can take one more look at the data using `transformed_df.head()` and `transformed_df.info()`. Save a copy of this data for use in future sections: - -```{code-cell} -transformed_df.head() -transformed_df.info() -transformed_df.to_csv("../../assets/data/cleaned_cuisines.csv ") -``` - ---- - -## Self study - -This curriculum contains several interesting datasets. Dig through the [/data/classification](https://github.com/YinYi000/machine-learning/tree/main/open-machine-learning-jupyter-book/assets/data) folders and see if any contain datasets that would be appropriate for binary or multi-class classification? What questions would you ask of this dataset? - -## Your turn! 🚀 - -Explore SMOTE's API. What use cases is it best used for? What problems does it solve? - -Assignment - [Explore classification methods](../../assignments/ml-fundamentals/explore-classification-methods.md) - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter. diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.ipynb new file mode 100644 index 0000000000..65f8b5f346 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.ipynb @@ -0,0 +1,908 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# More classifiers\n", + "\n", + "In this section, you will use the dataset you saved from the last section full of balanced, clean data all about cuisines.\n", + "\n", + "You will use this dataset with a variety of classifiers to _predict a given national cuisine based on a group of ingredients_. While doing so, you'll learn more about some of the ways that algorithms can be leveraged for classification tasks.\n", + "\n", + "## Exercise - predict a national cuisine\n", + "\n", + "1\\. Working in this section's [build-classification-models](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/ml-fundamentals/build-classification-models.ipynb) file, import that file along with the Pandas library:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0cuisinealmondangelicaaniseanise_seedappleapple_brandyapricotarmagnac...whiskeywhite_breadwhite_winewhole_grain_wheat_flourwinewoodyamyeastyogurtzucchini
00indian00000000...0000000000
11indian10000000...0000000000
22indian00000000...0000000000
33indian00000000...0000000000
44indian00000000...0000000010
\n", + "

5 rows × 382 columns

\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n", + "0 0 indian 0 0 0 0 0 \n", + "1 1 indian 1 0 0 0 0 \n", + "2 2 indian 0 0 0 0 0 \n", + "3 3 indian 0 0 0 0 0 \n", + "4 4 indian 0 0 0 0 0 \n", + "\n", + " apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n", + "0 0 0 0 ... 0 0 0 \n", + "1 0 0 0 ... 0 0 0 \n", + "2 0 0 0 ... 0 0 0 \n", + "3 0 0 0 ... 0 0 0 \n", + "4 0 0 0 ... 0 0 0 \n", + "\n", + " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n", + "0 0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 1 0 \n", + "\n", + "[5 rows x 382 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "import pandas as pd\n", + "cuisines_df = pd.read_csv(\"https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/classification/cleaned_cuisines.csv\")\n", + "cuisines_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2\\. Now, import several more libraries:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve\n", + "from sklearn.svm import SVC\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3\\. Divide the x and y coordinates into two dataframes for training. `cuisine` can be the labels dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 indian\n", + "1 indian\n", + "2 indian\n", + "3 indian\n", + "4 indian\n", + "Name: cuisine, dtype: object" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cuisines_label_df = cuisines_df['cuisine']\n", + "cuisines_label_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4\\. Drop that `Unnamed: 0` column and the `cuisine` column, calling `drop()`. Save the rest of the data as trainable features:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
almondangelicaaniseanise_seedappleapple_brandyapricotarmagnacartemisiaartichoke...whiskeywhite_breadwhite_winewhole_grain_wheat_flourwinewoodyamyeastyogurtzucchini
00000000000...0000000000
11000000000...0000000000
20000000000...0000000000
30000000000...0000000000
40000000000...0000000010
\n", + "

5 rows × 380 columns

\n", + "
" + ], + "text/plain": [ + " almond angelica anise anise_seed apple apple_brandy apricot \\\n", + "0 0 0 0 0 0 0 0 \n", + "1 1 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 0 0 \n", + "\n", + " armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n", + "0 0 0 0 ... 0 0 0 \n", + "1 0 0 0 ... 0 0 0 \n", + "2 0 0 0 ... 0 0 0 \n", + "3 0 0 0 ... 0 0 0 \n", + "4 0 0 0 ... 0 0 0 \n", + "\n", + " whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n", + "0 0 0 0 0 0 0 0 \n", + "1 0 0 0 0 0 0 0 \n", + "2 0 0 0 0 0 0 0 \n", + "3 0 0 0 0 0 0 0 \n", + "4 0 0 0 0 0 1 0 \n", + "\n", + "[5 rows x 380 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", + "cuisines_feature_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now you are ready to train your model!\n", + "\n", + "## Choosing your classifier\n", + "\n", + "Now that your data is clean and ready for training, you have to decide which algorithm to use for the job. \n", + "\n", + "Scikit-learn groups classification under Supervised Learning, and in that category you will find many ways to classify. [The variety](https://scikit-learn.org/stable/supervised_learning.html) is quite bewildering at first sight. The following methods all include classification techniques:\n", + "\n", + "- Linear Models\n", + "- Support Vector Machines\n", + "- Stochastic Gradient Descent\n", + "- Nearest Neighbors\n", + "- Gaussian Processes\n", + "- Decision Trees\n", + "- Ensemble methods (voting Classifier)\n", + "- Multiclass and multioutput algorithms (multiclass and multilabel classification, multiclass-multioutput classification)\n", + "\n", + ":::{seealso}\n", + "You can also use [neural networks to classify data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), but that is outside the scope of this section.\n", + ":::\n", + "\n", + "### What classifier to go with?\n", + "\n", + "So, which classifier should you choose? Often, running through several and looking for a good result is a way to test. Scikit-learn offers a [side-by-side comparison](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) on a created dataset, comparing KNeighbors, SVC two ways, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB and QuadraticDiscrinationAnalysis, showing the results visualized:\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/comparison.png\n", + "---\n", + "name: 'comparison of classifiers'\n", + "width: 90%\n", + "---\n", + "Comparison of classifiers [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/comparison.png)\n", + ":::\n", + "\n", + ":::{seealso}\n", + "Plots generated on Scikit-learn's documentation.\n", + "\n", + "AutoML solves this problem neatly by running these comparisons in the cloud, allowing you to choose the best algorithm for your data. Try it [here](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott).\n", + ":::\n", + "\n", + "### A better approach\n", + "\n", + "A better way than wildly guessing, however, is to follow the ideas on this downloadable [ML Cheat sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Here, we discover that, for our multiclass problem, we have some choices:\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/cheatsheet.png\n", + "---\n", + "name: 'cheatsheet for multiclass problems'\n", + "width: 90%\n", + "---\n", + "Cheatsheet for multiclass problems [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/cheatsheet.png)\n", + ":::\n", + "\n", + ":::{note}\n", + "A section of Microsoft's Algorithm Cheat Sheet, detailing multiclass classification options.\n", + ":::\n", + "\n", + ":::{seealso}\n", + "Download this cheat sheet, print it out, and hang it on your wall!\n", + ":::\n", + "\n", + "### Reasoning\n", + "\n", + "Let's see if we can reason our way through different approaches given the constraints we have:\n", + "\n", + "- **Neural networks are too heavy**. Given our clean, but minimal dataset, and the fact that we are running training locally via notebooks, neural networks are too heavyweight for this task.\n", + "- **No two-class classifier**. We do not use a two-class classifier, so that rules out one-vs-all. \n", + "- **Decision tree or logistic regression could work**. A decision tree might work, or logistic regression for multiclass data. \n", + "- **Multiclass Boosted Decision Trees solve a different problem**. The multiclass boosted decision tree is most suitable for nonparametric tasks, e.g. tasks designed to build rankings, so it is not useful for us.\n", + "\n", + "### Using Scikit-learn \n", + "\n", + "We will be using Scikit-learn to analyze our data. However, there are many ways to use logistic regression in Scikit-learn. Take a look at the [parameters to pass](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression). \n", + "\n", + "Essentially there are two important parameters - `multi_class` and `solver` - that we need to specify, when we ask Scikit-learn to perform a logistic regression. The `multi_class` value applies a certain behavior. The value of the solver is what algorithm to use. Not all solvers can be paired with all `multi_class` values.\n", + "\n", + "According to the docs, in the multiclass case, the training algorithm:\n", + "\n", + "- **Uses the one-vs-rest (OvR) scheme**, if the `multi_class` option is set to `ovr`.\n", + "- **Uses the cross-entropy loss**, if the `multi_class` option is set to `multinomial`. (Currently the `multinomial` option is supported only by the ‘lbfgs’, ‘sag’, ‘saga’ and ‘newton-cg’ solvers.)\n", + "\n", + ":::{seealso}\n", + "The 'scheme' here can either be 'ovr' (one-vs-rest) or 'multinomial'. Since logistic regression is really designed to support binary classification, these schemes allow it to better handle multiclass classification tasks. [🔗source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)\n", + "\n", + "The 'solver' is defined as \"the algorithm to use in the optimization problem\". [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).\n", + ":::\n", + "\n", + "Scikit-learn offers this table to explain how solvers handle different challenges presented by different kinds of data structures:\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/solvers.png\n", + "---\n", + "name: 'solvers'\n", + "width: 90%\n", + "---\n", + "Solvers [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/solvers.png)\n", + ":::\n", + "\n", + "## Exercise - split the data\n", + "\n", + "We can focus on logistic regression for our first training trial since you recently learned about the latter in a previous section.\n", + "Split your data into training and testing groups by calling `train_test_split()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise - apply logistic regression\n", + "\n", + "Since you are using the multiclass case, you need to choose what _scheme_ to use and what _solver_ to set. Use LogisticRegression with a multiclass setting and the **liblinear** solver to train.\n", + "\n", + "1\\. Create a logistic regression with multi_class set to `ovr` and the solver set to `liblinear`:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy is 0.8256880733944955\n" + ] + } + ], + "source": [ + "lr = LogisticRegression(multi_class='ovr',solver='liblinear')\n", + "model = lr.fit(X_train, np.ravel(y_train))\n", + "\n", + "accuracy = model.score(X_test, y_test)\n", + "print (\"Accuracy is {}\".format(accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{seealso}\n", + "Try a different solver like `lbfgs`, which is often set as default.\n", + ":::\n", + "\n", + ":::{note}\n", + "Use Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) function to flatten your data when needed.\n", + ":::\n", + "\n", + "The accuracy is good at over **80%**!\n", + "\n", + "2\\. You can see this model in action by testing one row of data (#50):" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ingredients: Index(['cinnamon', 'cream', 'egg', 'milk', 'milk_fat'], dtype='object')\n", + "cuisine: indian\n" + ] + } + ], + "source": [ + "print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')\n", + "print(f'cuisine: {y_test.iloc[50]}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{seealso}\n", + "Try a different row number and check the results.\n", + ":::\n", + "\n", + "3\\. Digging deeper, you can check for the accuracy of this prediction:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0
indian0.583259
japanese0.177337
chinese0.130770
korean0.090274
thai0.018360
\n", + "
" + ], + "text/plain": [ + " 0\n", + "indian 0.583259\n", + "japanese 0.177337\n", + "chinese 0.130770\n", + "korean 0.090274\n", + "thai 0.018360" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test= X_test.iloc[50].values.reshape(-1, 1).T\n", + "proba = model.predict_proba(test)\n", + "classes = model.classes_\n", + "resultdf = pd.DataFrame(data=proba, columns=classes)\n", + "\n", + "topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])\n", + "topPrediction.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{seealso}\n", + "Can you explain why the model is pretty sure this is an Indian cuisine?\n", + ":::\n", + "\n", + "4\\. Get more detail by printing a classification report, as you did in the regression sections:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " chinese 0.74 0.76 0.75 243\n", + " indian 0.92 0.92 0.92 213\n", + " japanese 0.81 0.77 0.79 251\n", + " korean 0.84 0.82 0.83 253\n", + " thai 0.83 0.87 0.85 239\n", + "\n", + " accuracy 0.83 1199\n", + " macro avg 0.83 0.83 0.83 1199\n", + "weighted avg 0.83 0.83 0.83 1199\n", + "\n" + ] + } + ], + "source": [ + "y_pred = model.predict(X_test)\n", + "print(classification_report(y_test,y_pred))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Your turn! 🚀\n", + "\n", + "In this section, you used your cleaned data to build a machine learning model that can predict a national cuisine based on a series of ingredients. Take some time to read through the many options Scikit-learn provides to classify data. Dig deeper into the concept of 'solver' to understand what goes on behind the scenes.\n", + "\n", + "Assignment - [Study the solvers](../../assignments/ml-fundamentals/study-the-solvers.md).\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.md b/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.md deleted file mode 100644 index 8466bca18f..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/classification/more-classifiers.md +++ /dev/null @@ -1,234 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# More classifiers - -In this section, you will use the dataset you saved from the last section full of balanced, clean data all about cuisines. - -You will use this dataset with a variety of classifiers to _predict a given national cuisine based on a group of ingredients_. While doing so, you'll learn more about some of the ways that algorithms can be leveraged for classification tasks. - -## Exercise - predict a national cuisine - -1\. Working in this section's [build-classification-models](../../assignments/ml-fundamentals/build-classification-models.ipynb) file, import that file along with the Pandas library: - -```{code-cell} -:tags: [output_scroll] - -import pandas as pd -cuisines_df = pd.read_csv("../../assets/data/classification/cleaned_cuisines.csv") -cuisines_df.head() -``` - -2\. Now, import several more libraries: - -```{code-cell} -from sklearn.linear_model import LogisticRegression -from sklearn.model_selection import train_test_split, cross_val_score -from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve -from sklearn.svm import SVC -import numpy as np -``` - -3\. Divide the x and y coordinates into two dataframes for training. `cuisine` can be the labels dataframe: - -```{code-cell} -cuisines_label_df = cuisines_df['cuisine'] -cuisines_label_df.head() -``` - -4\. Drop that `Unnamed: 0` column and the `cuisine` column, calling `drop()`. Save the rest of the data as trainable features: - -```{code-cell} -:tags: [output_scroll] - -cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1) -cuisines_feature_df.head() -``` - -Now you are ready to train your model! - -## Choosing your classifier - -Now that your data is clean and ready for training, you have to decide which algorithm to use for the job. - -Scikit-learn groups classification under Supervised Learning, and in that category you will find many ways to classify. [The variety](https://scikit-learn.org/stable/supervised_learning.html) is quite bewildering at first sight. The following methods all include classification techniques: - -- Linear Models -- Support Vector Machines -- Stochastic Gradient Descent -- Nearest Neighbors -- Gaussian Processes -- Decision Trees -- Ensemble methods (voting Classifier) -- Multiclass and multioutput algorithms (multiclass and multilabel classification, multiclass-multioutput classification) - -```{seealso} -You can also use [neural networks to classify data](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), but that is outside the scope of this section. -``` - -### What classifier to go with? - -So, which classifier should you choose? Often, running through several and looking for a good result is a way to test. Scikit-learn offers a [side-by-side comparison](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) on a created dataset, comparing KNeighbors, SVC two ways, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB and QuadraticDiscrinationAnalysis, showing the results visualized: - -```{figure} ../../../images/ml-fundamentals/ml-classification/comparison.png ---- -name: 'comparison of classifiers' -width: 90% ---- -Comparison of classifiers [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/comparison.png) -``` - -```{seealso} -Plots generated on Scikit-learn's documentation. - -AutoML solves this problem neatly by running these comparisons in the cloud, allowing you to choose the best algorithm for your data. Try it [here](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott). -``` - -### A better approach - -A better way than wildly guessing, however, is to follow the ideas on this downloadable [ML Cheat sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott). Here, we discover that, for our multiclass problem, we have some choices: - -```{figure} ../../../images/ml-fundamentals/ml-classification/cheatsheet.png ---- -name: 'cheatsheet for multiclass problems' -width: 90% ---- -Cheatsheet for multiclass problems [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/cheatsheet.png) -``` - -```{note} -A section of Microsoft's Algorithm Cheat Sheet, detailing multiclass classification options. -``` - -```{seealso} -Download this cheat sheet, print it out, and hang it on your wall! -``` - -### Reasoning - -Let's see if we can reason our way through different approaches given the constraints we have: - -- **Neural networks are too heavy**. Given our clean, but minimal dataset, and the fact that we are running training locally via notebooks, neural networks are too heavyweight for this task. -- **No two-class classifier**. We do not use a two-class classifier, so that rules out one-vs-all. -- **Decision tree or logistic regression could work**. A decision tree might work, or logistic regression for multiclass data. -- **Multiclass Boosted Decision Trees solve a different problem**. The multiclass boosted decision tree is most suitable for nonparametric tasks, e.g. tasks designed to build rankings, so it is not useful for us. - -### Using Scikit-learn - -We will be using Scikit-learn to analyze our data. However, there are many ways to use logistic regression in Scikit-learn. Take a look at the [parameters to pass](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression). - -Essentially there are two important parameters - `multi_class` and `solver` - that we need to specify, when we ask Scikit-learn to perform a logistic regression. The `multi_class` value applies a certain behavior. The value of the solver is what algorithm to use. Not all solvers can be paired with all `multi_class` values. - -According to the docs, in the multiclass case, the training algorithm: - -- **Uses the one-vs-rest (OvR) scheme**, if the `multi_class` option is set to `ovr`. -- **Uses the cross-entropy loss**, if the `multi_class` option is set to `multinomial`. (Currently the `multinomial` option is supported only by the ‘lbfgs’, ‘sag’, ‘saga’ and ‘newton-cg’ solvers.) - -```{seealso} -The 'scheme' here can either be 'ovr' (one-vs-rest) or 'multinomial'. Since logistic regression is really designed to support binary classification, these schemes allow it to better handle multiclass classification tasks. [🔗source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/) - -The 'solver' is defined as "the algorithm to use in the optimization problem". [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression). -``` - -Scikit-learn offers this table to explain how solvers handle different challenges presented by different kinds of data structures: - -```{figure} ../../../images/ml-fundamentals/ml-classification/solvers.png ---- -name: 'solvers' -width: 90% ---- -Solvers [🔗source](https://github.com/microsoft/ML-For-Beginners/blob/main/4-Classification/2-Classifiers-1/images/solvers.png) -``` - -## Exercise - split the data - -We can focus on logistic regression for our first training trial since you recently learned about the latter in a previous section. -Split your data into training and testing groups by calling `train_test_split()`: - -```{code-cell} -X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3) -``` - -## Exercise - apply logistic regression - -Since you are using the multiclass case, you need to choose what _scheme_ to use and what _solver_ to set. Use LogisticRegression with a multiclass setting and the **liblinear** solver to train. - -1\. Create a logistic regression with multi_class set to `ovr` and the solver set to `liblinear`: - -```{code-cell} -lr = LogisticRegression(multi_class='ovr',solver='liblinear') -model = lr.fit(X_train, np.ravel(y_train)) - -accuracy = model.score(X_test, y_test) -print ("Accuracy is {}".format(accuracy)) -``` - -```{seealso} -Try a different solver like `lbfgs`, which is often set as default. -``` - -```{note} -Use Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) function to flatten your data when needed. -``` - -The accuracy is good at over **80%**! - -2\. You can see this model in action by testing one row of data (#50): - -```{code-cell} -print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}') -print(f'cuisine: {y_test.iloc[50]}') -``` - -```{seealso} -Try a different row number and check the results. -``` - -3\. Digging deeper, you can check for the accuracy of this prediction: - -```{code-cell} -test= X_test.iloc[50].values.reshape(-1, 1).T -proba = model.predict_proba(test) -classes = model.classes_ -resultdf = pd.DataFrame(data=proba, columns=classes) - -topPrediction = resultdf.T.sort_values(by=[0], ascending = [False]) -topPrediction.head() -``` - -```{seealso} -Can you explain why the model is pretty sure this is an Indian cuisine? -``` - -4\. Get more detail by printing a classification report, as you did in the regression sections: - -```{code-cell} -y_pred = model.predict(X_test) -print(classification_report(y_test,y_pred)) -``` - -## Self Study - -Dig a little more into the math behind logistic regression in [this section](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf). - -## Your turn! 🚀 - -In this section, you used your cleaned data to build a machine learning model that can predict a national cuisine based on a series of ingredients. Take some time to read through the many options Scikit-learn provides to classify data. Dig deeper into the concept of 'solver' to understand what goes on behind the scenes. - -Assignment - [Study the solvers](../../assignments/ml-fundamentals/study-the-solvers.md). - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter. \ No newline at end of file diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.ipynb new file mode 100644 index 0000000000..cb0ccb62d8 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.ipynb @@ -0,0 +1,513 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-cell" + ] + }, + "source": [ + "---\n", + "jupytext:\n", + " cell_metadata_filter: -all\n", + " formats: md:myst\n", + " text_representation:\n", + " extension: .md\n", + " format_name: myst\n", + " format_version: 0.13\n", + " jupytext_version: 1.11.5\n", + "kernelspec:\n", + " display_name: Python 3\n", + " language: python\n", + " name: python3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys \n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "# Yet other classifiers\n", + "\n", + "In this second classification section, you will explore more ways to classify numeric data. You will also learn about the ramifications for choosing one classifier over the other.\n", + "\n", + "## Preparation\n", + "\n", + "We have loaded your [build-classification-model.ipynb](https://static-1300131294.cos.ap-shanghai.myqcloud.com/assignments/ml-fundamentals/build-classification-model.ipynb) file with the cleaned dataset and have divided it into x and y dataframes, ready for the model building process.\n", + "\n", + "## A classification map\n", + "\n", + "Previously, you learned about the various options you have when classifying data using Microsoft's cheat sheet. Scikit-learn offers a similar, but more granular cheat sheet that can further help narrow down your estimators (another term for classifiers):\n", + "\n", + ":::{figure} https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/ml-fundamentals/ml-classification/map.png\n", + "---\n", + "name: 'ML Map from Scikit-learn'\n", + "width: 90%\n", + "---\n", + "ML Map from Scikit-learn. [Ref](https://scikit-learn.org/stable/tutorial/machine_learning_map/)\n", + ":::\n", + "\n", + "### The plan\n", + "\n", + "This map is very helpful once you have a clear grasp of your data, as you can 'walk' along its paths to a decision:\n", + "\n", + "- We have >50 samples\n", + "- We want to predict a category\n", + "- We have labeled data\n", + "- We have fewer than 100K samples\n", + "- ✨ We can choose a Linear SVC\n", + "- If that doesn't work, since we have numeric data\n", + " - We can try a ✨ KNeighbors Classifier \n", + " - If that doesn't work, try ✨ SVC and ✨ Ensemble Classifiers\n", + "\n", + "This is a very helpful trail to follow.\n", + "\n", + "## Exercise - split the data\n", + "\n", + "Following this path, we should start by importing some libraries to use.\n", + "\n", + "1\\. Import the needed libraries:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import SVC\n", + "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "cuisines_df = pd.read_csv(\"https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/classification/cleaned_cuisines.csv\")\n", + "cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", + "cuisines_label_df = cuisines_df['cuisine']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2\\. Split your training and test data:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Linear SVC classifier\n", + "\n", + "Support-Vector clustering (SVC) is a child of the Support-Vector machines family of ML techniques (learn more about these below). In this method, you can choose a 'kernel' to decide how to cluster the labels. The 'C' parameter refers to 'regularization' which regulates the influence of parameters. The kernel can be one of [several](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); here we set it to 'linear' to ensure that we leverage linear SVC. Probability defaults to 'false'; here we set it to 'true' to gather probability estimates. We set the random state to '0' to shuffle the data to get probabilities.\n", + "\n", + "### Exercise - apply a linear SVC\n", + "\n", + "Start by creating an array of classifiers. You will add progressively to this array as we test. \n", + "\n", + "1\\. Start with a Linear SVC:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "C = 10\n", + "# Create different classifiers.\n", + "classifiers = {\n", + " 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2\\. Train your model using the Linear SVC and print out a report:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy (train) for Linear SVC: 79.4% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.66 0.72 0.69 223\n", + " indian 0.91 0.89 0.90 255\n", + " japanese 0.76 0.75 0.76 244\n", + " korean 0.90 0.73 0.81 225\n", + " thai 0.77 0.85 0.81 252\n", + "\n", + " accuracy 0.79 1199\n", + " macro avg 0.80 0.79 0.79 1199\n", + "weighted avg 0.80 0.79 0.80 1199\n", + "\n" + ] + } + ], + "source": [ + "n_classifiers = len(classifiers)\n", + "\n", + "def classify():\n", + " for index, (name, classifier) in enumerate(classifiers.items()):\n", + " classifier.fit(X_train, np.ravel(y_train))\n", + "\n", + " y_pred = classifier.predict(X_test)\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " print(\"Accuracy (train) for %s: %0.1f%% \" % (name, accuracy * 100))\n", + " print(classification_report(y_test,y_pred))\n", + "\n", + "classify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is pretty good.\n", + "\n", + "## K-Neighbors classifier\n", + "\n", + "K-Neighbors is part of the \"neighbors\" family of ML methods, which can be used for both supervised and unsupervised learning. In this method, a predefined number of points is created and data are gathered around these points such that generalized labels can be predicted for the data.\n", + "\n", + "### Exercise - apply the K-Neighbors classifier\n", + "\n", + "The previous classifier was good, and worked well with the data, but maybe we can get better accuracy. Try a K-Neighbors classifier.\n", + "\n", + "1\\. Add a line to your classifier array (add a comma after the Linear SVC item):" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy (train) for Linear SVC: 79.4% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.66 0.72 0.69 223\n", + " indian 0.91 0.89 0.90 255\n", + " japanese 0.76 0.75 0.76 244\n", + " korean 0.90 0.73 0.81 225\n", + " thai 0.77 0.85 0.81 252\n", + "\n", + " accuracy 0.79 1199\n", + " macro avg 0.80 0.79 0.79 1199\n", + "weighted avg 0.80 0.79 0.80 1199\n", + "\n", + "Accuracy (train) for KNN classifier: 73.1% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.62 0.66 0.64 223\n", + " indian 0.89 0.78 0.83 255\n", + " japanese 0.65 0.85 0.73 244\n", + " korean 0.91 0.55 0.68 225\n", + " thai 0.71 0.79 0.75 252\n", + "\n", + " accuracy 0.73 1199\n", + " macro avg 0.76 0.73 0.73 1199\n", + "weighted avg 0.76 0.73 0.73 1199\n", + "\n" + ] + } + ], + "source": [ + "classifiers['KNN classifier'] = KNeighborsClassifier(C)\n", + "\n", + "classify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is a little worse.\n", + "\n", + ":::{seealso}\n", + "Learn about [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)\n", + ":::\n", + "\n", + "## Support Vector Classifier\n", + "\n", + "Support-Vector classifiers are part of the [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) family of ML methods that are used for classification and regression tasks. SVMs \"map training examples to points in space\" to maximize the distance between two categories. Subsequent data is mapped into this space so their category can be predicted.\n", + "\n", + "### Exercise - apply a Support Vector Classifier\n", + "\n", + "Let's try for a little better accuracy with a Support Vector Classifier.\n", + "\n", + "1\\. Add a comma after the K-Neighbors item, and then add this line:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy (train) for Linear SVC: 79.4% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.66 0.72 0.69 223\n", + " indian 0.91 0.89 0.90 255\n", + " japanese 0.76 0.75 0.76 244\n", + " korean 0.90 0.73 0.81 225\n", + " thai 0.77 0.85 0.81 252\n", + "\n", + " accuracy 0.79 1199\n", + " macro avg 0.80 0.79 0.79 1199\n", + "weighted avg 0.80 0.79 0.80 1199\n", + "\n", + "Accuracy (train) for KNN classifier: 73.1% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.62 0.66 0.64 223\n", + " indian 0.89 0.78 0.83 255\n", + " japanese 0.65 0.85 0.73 244\n", + " korean 0.91 0.55 0.68 225\n", + " thai 0.71 0.79 0.75 252\n", + "\n", + " accuracy 0.73 1199\n", + " macro avg 0.76 0.73 0.73 1199\n", + "weighted avg 0.76 0.73 0.73 1199\n", + "\n", + "Accuracy (train) for SVC: 82.0% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.73 0.73 0.73 223\n", + " indian 0.90 0.89 0.90 255\n", + " japanese 0.80 0.80 0.80 244\n", + " korean 0.92 0.80 0.86 225\n", + " thai 0.77 0.87 0.82 252\n", + "\n", + " accuracy 0.82 1199\n", + " macro avg 0.82 0.82 0.82 1199\n", + "weighted avg 0.82 0.82 0.82 1199\n", + "\n" + ] + } + ], + "source": [ + "classifiers['SVC'] = SVC()\n", + "\n", + "classify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is quite good!\n", + "\n", + ":::{seealso}\n", + "Learn about [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm)\n", + ":::\n", + "\n", + "## Ensemble Classifiers\n", + "\n", + "Let's follow the path to the very end, even though the previous test was quite good. Let's try some 'Ensemble Classifiers, specifically Random Forest and AdaBoost:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy (train) for Linear SVC: 79.4% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.66 0.72 0.69 223\n", + " indian 0.91 0.89 0.90 255\n", + " japanese 0.76 0.75 0.76 244\n", + " korean 0.90 0.73 0.81 225\n", + " thai 0.77 0.85 0.81 252\n", + "\n", + " accuracy 0.79 1199\n", + " macro avg 0.80 0.79 0.79 1199\n", + "weighted avg 0.80 0.79 0.80 1199\n", + "\n", + "Accuracy (train) for KNN classifier: 73.1% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.62 0.66 0.64 223\n", + " indian 0.89 0.78 0.83 255\n", + " japanese 0.65 0.85 0.73 244\n", + " korean 0.91 0.55 0.68 225\n", + " thai 0.71 0.79 0.75 252\n", + "\n", + " accuracy 0.73 1199\n", + " macro avg 0.76 0.73 0.73 1199\n", + "weighted avg 0.76 0.73 0.73 1199\n", + "\n", + "Accuracy (train) for SVC: 82.0% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.73 0.73 0.73 223\n", + " indian 0.90 0.89 0.90 255\n", + " japanese 0.80 0.80 0.80 244\n", + " korean 0.92 0.80 0.86 225\n", + " thai 0.77 0.87 0.82 252\n", + "\n", + " accuracy 0.82 1199\n", + " macro avg 0.82 0.82 0.82 1199\n", + "weighted avg 0.82 0.82 0.82 1199\n", + "\n", + "Accuracy (train) for RFST: 84.7% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.78 0.80 0.79 223\n", + " indian 0.94 0.91 0.93 255\n", + " japanese 0.85 0.79 0.82 244\n", + " korean 0.89 0.81 0.85 225\n", + " thai 0.79 0.92 0.85 252\n", + "\n", + " accuracy 0.85 1199\n", + " macro avg 0.85 0.84 0.85 1199\n", + "weighted avg 0.85 0.85 0.85 1199\n", + "\n", + "Accuracy (train) for ADA: 68.6% \n", + " precision recall f1-score support\n", + "\n", + " chinese 0.55 0.49 0.52 223\n", + " indian 0.87 0.84 0.86 255\n", + " japanese 0.63 0.60 0.62 244\n", + " korean 0.66 0.75 0.70 225\n", + " thai 0.69 0.73 0.71 252\n", + "\n", + " accuracy 0.69 1199\n", + " macro avg 0.68 0.68 0.68 1199\n", + "weighted avg 0.68 0.69 0.68 1199\n", + "\n" + ] + } + ], + "source": [ + "classifiers['RFST'] = RandomForestClassifier(n_estimators=100)\n", + "classifiers['ADA'] = AdaBoostClassifier(n_estimators=100)\n", + "\n", + "classify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result is very good, especially for Random Forest.\n", + "\n", + ":::{seealso}\n", + "Learn about [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html)\n", + ":::\n", + "\n", + "This method of Machine Learning \"combines the predictions of several base estimators\" to improve the model's quality. In our example, we used Random Trees and AdaBoost.\n", + "\n", + "- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), an averaging method, builds a 'forest' of 'decision trees' infused with randomness to avoid overfitting. The n_estimators parameter is set to the number of trees.\n", + "\n", + "- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) fits a classifier to a dataset and then fits copies of that classifier to the same dataset. It focuses on the weights of incorrectly classified items and adjusts the fit for the next classifier to correct.\n", + "\n", + "---\n", + "\n", + "## Self Study\n", + "\n", + "There's a lot of jargon in these sections, so take a minute to review [this list](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) of useful terminology!\n", + "\n", + "## Your turn! 🚀\n", + "\n", + "Each of these techniques has a large number of parameters that you can tweak. Research each one's default parameters and think about what tweaking these parameters would mean for the model's quality.\n", + "\n", + "Assignment - [Parameter play](../../assignments/ml-fundamentals/parameter-play.md)\n", + "\n", + "## Acknowledgments\n", + "\n", + "Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.md b/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.md deleted file mode 100644 index 979cb1591a..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/classification/yet-other-classifiers.md +++ /dev/null @@ -1,196 +0,0 @@ ---- -jupytext: - cell_metadata_filter: -all - formats: md:myst - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.11.5 -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Yet other classifiers - -In this second classification section, you will explore more ways to classify numeric data. You will also learn about the ramifications for choosing one classifier over the other. - -## Preparation - -We have loaded your [build-classification-model.ipynb](../../assignments/ml-fundamentals/build-classification-model.ipynb) file with the cleaned dataset and have divided it into x and y dataframes, ready for the model building process. - -## A classification map - -Previously, you learned about the various options you have when classifying data using Microsoft's cheat sheet. Scikit-learn offers a similar, but more granular cheat sheet that can further help narrow down your estimators (another term for classifiers): - -```{figure} ../../../images/ml-fundamentals/ml-classification/map.png ---- -name: 'ML Map from Scikit-learn' -width: 90% ---- -ML Map from Scikit-learn. [Ref](https://scikit-learn.org/stable/tutorial/machine_learning_map/) -``` - -### The plan - -This map is very helpful once you have a clear grasp of your data, as you can 'walk' along its paths to a decision: - -- We have >50 samples -- We want to predict a category -- We have labeled data -- We have fewer than 100K samples -- ✨ We can choose a Linear SVC -- If that doesn't work, since we have numeric data - - We can try a ✨ KNeighbors Classifier - - If that doesn't work, try ✨ SVC and ✨ Ensemble Classifiers - -This is a very helpful trail to follow. - -## Exercise - split the data - -Following this path, we should start by importing some libraries to use. - -1\. Import the needed libraries: - -```{code-cell} -from sklearn.neighbors import KNeighborsClassifier -from sklearn.linear_model import LogisticRegression -from sklearn.svm import SVC -from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier -from sklearn.model_selection import train_test_split, cross_val_score -from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve -import numpy as np -import pandas as pd - -cuisines_df = pd.read_csv("../../assets/data/classification/cleaned_cuisines.csv") -cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1) -cuisines_label_df = cuisines_df['cuisine'] -``` - -2\. Split your training and test data: - -```{code-cell} -X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3) -``` - -## Linear SVC classifier - -Support-Vector clustering (SVC) is a child of the Support-Vector machines family of ML techniques (learn more about these below). In this method, you can choose a 'kernel' to decide how to cluster the labels. The 'C' parameter refers to 'regularization' which regulates the influence of parameters. The kernel can be one of [several](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); here we set it to 'linear' to ensure that we leverage linear SVC. Probability defaults to 'false'; here we set it to 'true' to gather probability estimates. We set the random state to '0' to shuffle the data to get probabilities. - -### Exercise - apply a linear SVC - -Start by creating an array of classifiers. You will add progressively to this array as we test. - -1\. Start with a Linear SVC: - -```{code-cell} -C = 10 -# Create different classifiers. -classifiers = { - 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0) -} -``` - -2\. Train your model using the Linear SVC and print out a report: - -```{code-cell} -n_classifiers = len(classifiers) - -def classify(): - for index, (name, classifier) in enumerate(classifiers.items()): - classifier.fit(X_train, np.ravel(y_train)) - - y_pred = classifier.predict(X_test) - accuracy = accuracy_score(y_test, y_pred) - print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100)) - print(classification_report(y_test,y_pred)) - -classify() -``` - -The result is pretty good. - -## K-Neighbors classifier - -K-Neighbors is part of the "neighbors" family of ML methods, which can be used for both supervised and unsupervised learning. In this method, a predefined number of points is created and data are gathered around these points such that generalized labels can be predicted for the data. - -### Exercise - apply the K-Neighbors classifier - -The previous classifier was good, and worked well with the data, but maybe we can get better accuracy. Try a K-Neighbors classifier. - -1\. Add a line to your classifier array (add a comma after the Linear SVC item): - -```{code-cell} -classifiers['KNN classifier'] = KNeighborsClassifier(C) - -classify() -``` - -The result is a little worse. - -```{seealso} -Learn about [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) -``` - -## Support Vector Classifier - -Support-Vector classifiers are part of the [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) family of ML methods that are used for classification and regression tasks. SVMs "map training examples to points in space" to maximize the distance between two categories. Subsequent data is mapped into this space so their category can be predicted. - -### Exercise - apply a Support Vector Classifier - -Let's try for a little better accuracy with a Support Vector Classifier. - -1\. Add a comma after the K-Neighbors item, and then add this line: - -```{code-cell} -classifiers['SVC'] = SVC() - -classify() -``` - -The result is quite good! - -```{seealso} -Learn about [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm) -``` - -## Ensemble Classifiers - -Let's follow the path to the very end, even though the previous test was quite good. Let's try some 'Ensemble Classifiers, specifically Random Forest and AdaBoost: - -```{code-cell} -classifiers['RFST'] = RandomForestClassifier(n_estimators=100) -classifiers['ADA'] = AdaBoostClassifier(n_estimators=100) - -classify() -``` - -The result is very good, especially for Random Forest. - -```{seealso} -Learn about [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html) -``` - -This method of Machine Learning "combines the predictions of several base estimators" to improve the model's quality. In our example, we used Random Trees and AdaBoost. - -- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), an averaging method, builds a 'forest' of 'decision trees' infused with randomness to avoid overfitting. The n_estimators parameter is set to the number of trees. - -- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) fits a classifier to a dataset and then fits copies of that classifier to the same dataset. It focuses on the weights of incorrectly classified items and adjusts the fit for the next classifier to correct. - ---- - -## Self Study - -There's a lot of jargon in these sections, so take a minute to review [this list](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) of useful terminology! - -## Your turn! 🚀 - -Each of these techniques has a large number of parameters that you can tweak. Research each one's default parameters and think about what tweaking these parameters would mean for the model's quality. - -Assignment - [Parameter play](../../assignments/ml-fundamentals/parameter-play.md) - -## Acknowledgments - -Thanks to Microsoft for creating the open-source course [ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners). It inspires the majority of the content in this chapter. diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/regression/linear-regression-metrics.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/regression/linear-regression-metrics.ipynb new file mode 100644 index 0000000000..ee56256090 --- /dev/null +++ b/open-machine-learning-jupyter-book/ml-fundamentals/regression/linear-regression-metrics.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "a23a2854-7e54-4a24-9ae4-0f8904f899ee", + "metadata": {}, + "outputs": [], + "source": [ + "# Install the necessary dependencies\n", + "\n", + "import os\n", + "import sys\n", + "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython\n" + ] + }, + { + "cell_type": "markdown", + "id": "3780e038-4395-44e7-9294-a54ae4bc731d", + "metadata": {}, + "source": [ + "---\n", + "license:\n", + " code: MIT\n", + " content: CC-BY-4.0\n", + "github: https://github.com/ocademy-ai/machine-learning\n", + "venue: By Ocademy\n", + "open_access: true\n", + "bibliography:\n", + " - https://raw.githubusercontent.com/ocademy-ai/machine-learning/main/open-machine-learning-jupyter-book/references.bib\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "63961ec0-328a-4289-8667-cc86f09db8f1", + "metadata": {}, + "source": [ + "# Linear Regression Metrics" + ] + }, + { + "cell_type": "markdown", + "id": "c556cae5-c568-444c-be0c-4a9f54a0af5b", + "metadata": {}, + "source": [ + "Linear regression is a fundamental and widely used technique in machine learning and statistics for predicting continuous values based on input variables. It finds its application in various domains, from finance and economics to healthcare and engineering. When using linear regression, it's essential to assess the model's performance accurately. This is where linear regression metrics come into play.\n", + "\n", + "In this tutorial, we will delve into the world of linear regression metrics, exploring the key evaluation measures that allow us to gauge how well a linear regression model fits the data and makes predictions. These metrics provide valuable insights into the model's accuracy, precision, and ability to capture the underlying relationships between variables.\n", + "\n", + "We will cover essential concepts such as Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R-squared (R2) score, and Mean Absolute Error (MAE). Understanding these metrics is crucial for data scientists, machine learning practitioners, and anyone looking to harness the power of linear regression for predictive modeling.\n", + "\n", + "Whether you are building models for price predictions, sales forecasts, or any other regression task, mastering these metrics will empower you to make informed decisions and fine-tune your models for optimal performance. Let's embark on this journey to explore the intricacies of linear regression metrics and enhance our ability to assess and improve regression models." + ] + }, + { + "cell_type": "markdown", + "id": "f39e137f-d413-4d64-97b7-d6500542e8ed", + "metadata": {}, + "source": [ + "## Mean Squared Error (MSE)" + ] + }, + { + "cell_type": "markdown", + "id": "f893cbed-c0e9-46c5-aea3-8871c7bb9a5d", + "metadata": {}, + "source": [ + "In the realm of linear regression metrics, one fundamental measure of model performance is the **Mean Squared Error (MSE)**. MSE serves as a valuable indicator of how well your linear regression model aligns its predictions with the actual data points. This metric quantifies the average of the squared differences between predicted values and observed values." + ] + }, + { + "cell_type": "markdown", + "id": "de348eec-516d-4d86-a02e-ccbe7dba7bf5", + "metadata": {}, + "source": [ + "### The Formula" + ] + }, + { + "cell_type": "markdown", + "id": "545bc42e-7ca4-4c9a-91ca-fceeebaa1b83", + "metadata": {}, + "source": [ + "Mathematically, the MSE is computed using the following formula:" + ] + }, + { + "cell_type": "markdown", + "id": "768aa918-1f0b-4ae5-b4c7-9e77097050e1", + "metadata": {}, + "source": [ + "$$ MSE = \\frac{1}{n} \\sum_{i=1}^{n} (y_i - \\hat{y}_i)^2 $$" + ] + }, + { + "cell_type": "markdown", + "id": "dbd49d92-4228-458e-a865-5d4636bd4ff2", + "metadata": {}, + "source": [ + "Where:\n", + "\n", + "- $n$ is the number of data points.\n", + "- $y_i$ represents the actual observed value for the $i^{th}$ data point.\n", + "- $\\hat{y}_i$ represents the predicted value for the $i^{th}$ data point." + ] + }, + { + "cell_type": "markdown", + "id": "54f58e2a-8d6e-4cfb-8a9a-ab50cdaaf956", + "metadata": {}, + "source": [ + "### Interpretation" + ] + }, + { + "cell_type": "markdown", + "id": "d09eadf6-21c1-488e-98f1-4e0917be18b6", + "metadata": {}, + "source": [ + "A lower MSE value indicates that the model's predictions are closer to the actual values, signifying better model performance. Conversely, a higher MSE suggests that the model's predictions deviate more from the true values, indicating poorer performance." + ] + }, + { + "cell_type": "markdown", + "id": "d2b803a5-b390-407a-886b-ccfcee059233", + "metadata": {}, + "source": [ + "### Python Implementation" + ] + }, + { + "cell_type": "markdown", + "id": "e546d69d-7542-4c65-9635-4d5dced7248e", + "metadata": {}, + "source": [ + "Let's take a look at how to calculate MSE in Python. We'll use a simple example with sample data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7b027b00-2205-4475-a600-62059c7fc5c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error (MSE): 0.5079999999999996\n" + ] + } + ], + "source": [ + "# Import necessary libraries\n", + "import numpy as np\n", + "\n", + "# Sample data for demonstration (replace with your actual data)\n", + "actual_values = np.array([22.1, 19.9, 24.5, 20.1, 18.7])\n", + "predicted_values = np.array([23.5, 20.2, 23.9, 19.8, 18.5])\n", + "\n", + "# Calculate the squared differences between actual and predicted values\n", + "squared_errors = (actual_values - predicted_values) ** 2\n", + "\n", + "# Calculate the mean of squared errors to get MSE\n", + "mse = np.mean(squared_errors)\n", + "\n", + "# Print the MSE\n", + "print(\"Mean Squared Error (MSE):\", mse)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "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.10.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/open-machine-learning-jupyter-book/ml-fundamentals/regression/loss-function.ipynb b/open-machine-learning-jupyter-book/ml-fundamentals/regression/loss-function.ipynb deleted file mode 100644 index defa7558a4..0000000000 --- a/open-machine-learning-jupyter-book/ml-fundamentals/regression/loss-function.ipynb +++ /dev/null @@ -1,830 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "776fc8b6-42b2-4b27-8596-8fa5a29ab556", - "metadata": {}, - "outputs": [], - "source": [ - "# Install the necessary dependencies\n", - "\n", - "import os\n", - "import sys\n", - "!{sys.executable} -m pip install --quiet pandas scikit-learn numpy matplotlib jupyterlab_myst ipython" - ] - }, - { - "cell_type": "markdown", - "id": "a3e2352b-17ee-4471-b4a8-7c192326abde", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "source": [ - "# Stock Market Prediction Hands-On: Training a Linear Regression Model (1/6)" - ] - }, - { - "cell_type": "markdown", - "id": "e8dc8e12-f3a4-4c24-bdd7-63fe322c9b52", - "metadata": {}, - "source": [ - "Can linear regression in machine learning predict the stock market? This real dataset includes stock market data from several major U.S. companies between 2005 and 2020, including daily opening and closing prices, highest and lowest prices, trading volume, turnover rate, and other information. Today, we are going to use it to practice and see if we will make a profit or incur losses." - ] - }, - { - "cell_type": "markdown", - "id": "41a37356-04f0-45f8-afef-185bd1a25015", - "metadata": {}, - "source": [ - "\"data-source\"" - ] - }, - { - "cell_type": "markdown", - "id": "20185c4e", - "metadata": {}, - "source": [ - "*You can download the corresponding kaggle dataset [here](https://www.kaggle.com/datasets/nikhilkohli/us-stock-market-data-60-extracted-features)*" - ] - }, - { - "cell_type": "markdown", - "id": "f5ee754a-e5d9-4532-86d5-1433722be122", - "metadata": {}, - "source": [ - "Let's begin by taking a look at Apple Inc., a company that has shown consistently robust performance over the years." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "595f6e94", - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn import metrics" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f9b66d7a", - "metadata": {}, - "outputs": [], - "source": [ - "df_stock = pd.read_csv('https://static-1300131294.cos.ap-shanghai.myqcloud.com/data/ml-fundamental/AAPL.csv', index_col=0)\n", - "df_stock = df_stock.rename(columns={'Close(t)':'Close'})\n", - "df_stock.head()" - ] - }, - { - "cell_type": "markdown", - "id": "59c28a72-b9d2-48e7-898e-fe67fb61a80e", - "metadata": {}, - "source": [ - "Here, we have a total of 3,732 days' worth of stock market data, with each row containing 63 columns. There's one particular column that stands out, known as 'Close_forecast,' which represents the stock's closing price for the next day. It's important to note that this column doesn't exist in the original scraped data; it was added by Kaggle to make the dataset more suitable for machine learning exercises.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eccfc31d", - "metadata": {}, - "outputs": [], - "source": [ - "df_stock.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "86a6d04f", - "metadata": {}, - "outputs": [], - "source": [ - "df_stock.columns" - ] - }, - { - "cell_type": "markdown", - "id": "59e74939-3af1-4967-9cf6-049d946c2bda", - "metadata": {}, - "source": [ - "We will select the 'Close_forecast' column as the target for our machine learning model, which serves as the label. The remaining 62 columns will be used as features. We will split the data, using 75% for training and 25% for testing." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e80b445f", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.preprocessing import StandardScaler\n", - "\n", - "X = df_stock.drop(columns=['Close_forcast'], axis=1)\n", - "y = df_stock['Close_forcast']\n", - "\n", - "scaler_X = StandardScaler()\n", - "X = scaler_X.fit_transform(X)\n", - "\n", - "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y, test_size=0.25, random_state=42)\n", - "\n", - "print(X_train.shape, X_test.shape)\n", - "print(y_train.shape, y_test.shape)" - ] - }, - { - "cell_type": "markdown", - "id": "083f151d-c523-4d8b-bd53-b339136f80d6", - "metadata": {}, - "source": [ - "Finally, with just two simple lines of code, we will call the `LinearRegression.fit` method from sklearn to train our linear regression model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "054a0309", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import LinearRegression\n", - "\n", - "lr = LinearRegression()\n", - "lr.fit(X_train, y_train)" - ] - }, - { - "cell_type": "markdown", - "id": "22239732-992a-43eb-82af-1977723c545f", - "metadata": {}, - "source": [ - "Now that we have our model, it's time to put it to the test on our testing dataset. We'll use the model to make predictions on the test set and evaluate its performance." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6d1ebf8f", - "metadata": {}, - "outputs": [], - "source": [ - "y_test_pred = lr.predict(X_test)\n", - "y_test_pred" - ] - }, - { - "cell_type": "markdown", - "id": "f61c02c1-85b2-4f66-baa6-acf6f136c1ce", - "metadata": {}, - "source": [ - "At first glance, the results might seem a bit surprising, given the significant fluctuations in the predicted stock prices. However, I can offer some reassurance that our linear regression model is functioning correctly, and in fact, it performs quite well. You can confidently use the code provided above. As for the reason behind the seemingly chaotic predictions, we will delve into a more detailed analysis in the upcoming sections." - ] - }, - { - "cell_type": "markdown", - "id": "c24f7565-7e8a-4849-9c97-aa21a04f5a3b", - "metadata": {}, - "source": [ - "# Stock Market Prediction Hands-On: Model Performance Evaluation (2/6)" - ] - }, - { - "cell_type": "markdown", - "id": "b4f4703e-4c03-40cb-bab1-bafd1a783d14", - "metadata": {}, - "source": [ - "In the previous segment, we attempted stock price prediction using linear regression on a real stock market dataset. The results seemed chaotic, with significant fluctuations and sharp ups and downs in stock prices. Can linear regression truly predict stock prices? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ccaf0610", - "metadata": {}, - "outputs": [], - "source": [ - "y_test_pred = lr.predict(X_test)\n", - "y_test_pred" - ] - }, - { - "cell_type": "markdown", - "id": "3cb3c136-8525-4c04-a7f1-ec333f280c88", - "metadata": {}, - "source": [ - "Strange occurrences often have underlying reasons. Let's take a closer look at what y_test in the test set actually looks like. As it turns out, when y_test was created, the order was shuffled. In fact, there's a parameter in sklearn's train_test_split function called 'shuffle,' which is set to 'True' by default. This means that by default, the order is shuffled when splitting the training and test sets.\n", - "\n", - "Shuffling the order itself isn't necessarily a problem, but in our daily lives, stock prices generally follow a relatively smooth curve over time. Therefore, the test results may initially appear odd because they don't align with common sense. If we set 'shuffle' to 'False,' we can avoid this situation. You might find it interesting to try this out for yourselves." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18e13828", - "metadata": {}, - "outputs": [], - "source": [ - "y_test" - ] - }, - { - "cell_type": "markdown", - "id": "c0730d30-e1df-47a1-95be-99db83e25c6f", - "metadata": {}, - "source": [ - "Here, we're taking the real y-label values from the training set and the predicted y-label values, placing them together, and then sorting them. By doing this, we can compare the two and observe that the differences between them are quite small on a daily basis." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1e7d2c2", - "metadata": {}, - "outputs": [], - "source": [ - "df_test_pred = pd.DataFrame(y_test.values, \n", - " columns=['Actual'], index=y_test.index)\n", - "df_test_pred['Predicted'] = y_test_pred\n", - "df_test_pred = df_test_pred.reset_index()\n", - "sorted_df_test_pred = df_test_pred.sort_values(by='Date')\n", - "sorted_df_test_pred = sorted_df_test_pred.reset_index()\n", - "sorted_df_test_pred = sorted_df_test_pred.drop(columns=['index'])\n", - "sorted_df_test_pred" - ] - }, - { - "cell_type": "markdown", - "id": "32828743-f31c-4a78-952e-ad5fb630d084", - "metadata": {}, - "source": [ - "Let's visualize the data using matplotlib to gain a clearer understanding. The results are highly promising, as the blue real values and the green predicted values almost perfectly overlap." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "707598b7", - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(sorted_df_test_pred.index, sorted_df_test_pred['Actual'], color='b')\n", - "plt.plot(sorted_df_test_pred.index, sorted_df_test_pred['Predicted'], color='g')\n", - "plt.grid(which=\"major\", color='k', linestyle='-.', linewidth=0.5)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a237101b-df0e-4b3f-89d7-9c0d2c69be50", - "metadata": {}, - "source": [ - "\n", - "We calculate the R-squared, MAPE, and other evaluation metrics, and the results are excellent, consistent with the previous analysis. All of this indicates that linear regression performs well when applied to this real stock market dataset." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "061bf353", - "metadata": {}, - "outputs": [], - "source": [ - "print(\"Test R-squared: \",metrics.r2_score(\n", - " y_test,y_test_pred))\n", - "print(\"Test MAPE: \", metrics.mean_absolute_percentage_error(\n", - " y_test,y_test_pred),\"%\")\n", - "print(\n", - " \"Test Mean Squared Error:\",\n", - " metrics.mean_squared_error(y_test, y_test_pred)\n", - ")\n", - "print(\"Test RMSE: \",np.sgrt(metrics.mean_squared_error(\n", - " y_test,y_test_pred)))\n", - "print(\"Test MAE: \", metrics.mean_absolute_error(\n", - "y_test, y_test_pred))" - ] - }, - { - "cell_type": "markdown", - "id": "a9ba5ae4-7fde-4be6-95d2-3f265e4e4357", - "metadata": {}, - "source": [ - "It's important to note that evaluation metrics are often calculated on the test dataset, but they can also be computed on both the training and test datasets for comparison. Why do I emphasize this? Because in the next segment, we'll delve into loss functions, and their computation is exclusively for the training dataset." - ] - }, - { - "cell_type": "markdown", - "id": "51b55a90-63f7-4312-90d5-0afe5ba13f20", - "metadata": {}, - "source": [ - "# Stock Market Prediction Hands-On: Introduction to Loss Functions (3/6)" - ] - }, - { - "cell_type": "markdown", - "id": "29e890c3-bf6d-402a-87e3-b3d3cfc8967f", - "metadata": {}, - "source": [ - "In past segments, we used linear regression to predict stock prices, tested it on the test set, and calculated evaluation metrics, with the model performing exceptionally well. We plot the daily closing prices of Apple Inc. from 2005 to 2022. If you bought Apple stock on the first day shown in the graph and held it until the last day, you would have roughly multiplied your investment many times over. However, achieving this in reality is exceedingly challenging." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fd27ed12", - "metadata": {}, - "outputs": [], - "source": [ - "df_stock['Close'].plot(figsize=(10, 6))\n", - "plt.title(\"Stock Price\", fontsize=13)\n", - "plt.ylabel('Price', fontsize=12)\n", - "plt.xlabel('Time', fontsize=12)\n", - "plt.grid(which=\"major\", color='k', linestyle='-.', linewidth=0.5)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e3524a2d", - "metadata": {}, - "source": [ - "As ordinary investors, we don't possess a time machine, and even if we have a strong belief in Apple's stock, we cannot predict what will happen 15 years into the future. Typically, we do not hold stocks for extended periods. Instead, we engage in short-term or medium-term investments. If the stock price shows substantial growth within a certain timeframe, we may choose to sell at a certain point, seizing the opportunity. Conversely, if the stock price remains stagnant or declines, we may also decide to sell at a specific point, implementing a timely stop-loss strategy." - ] - }, - { - "cell_type": "markdown", - "id": "b74592d5-2619-48ef-a235-c7cb9a60cb91", - "metadata": {}, - "source": [ - "Of course, we can't provide stock investment strategies here, but if machine learning can effectively predict stock prices, it can certainly assist in shaping our investment strategies. With model predictions, we can observe that Apple's stock steadily increased over 15 years, indicating that buying in 2005 and selling in 2020 would have been profitable.\n" - ] - }, - { - "cell_type": "markdown", - "id": "f6411620-3125-4cf9-874a-10c4b19e217e", - "metadata": {}, - "source": [ - "Furthermore, if the model we've developed provides accurate predictions at finer granularities, we could potentially engage in multiple trades within those 15 years. Selling all stocks at local highs whenever the price is about to drop and buying in at local lows when the price is about to rise can optimize returns even further. However, this scenario assumes that our predictions align perfectly with reality, which, in practice, is unlikely to be the case." - ] - }, - { - "cell_type": "markdown", - "id": "64c50fc2-dfb3-427c-958e-6044711155ba", - "metadata": {}, - "source": [ - "\"meme-reality\"" - ] - }, - { - "cell_type": "markdown", - "id": "e2736fce-21ae-4ff2-ad64-f654c9362ee5", - "metadata": {}, - "source": [ - "While the evaluation metrics indicate that our model's performance is good, is it good enough to support the second investment strategy mentioned earlier? Or can it be further optimized to help us earn more from that strategy?\n", - "\n", - "The answer is affirmative, and here we introduce a new concept: the Loss Function, also known as the Cost Function. It is used to measure the difference or error between model predictions and real values on the training dataset. In the next segment, we will delve into how to calculate the loss function." - ] - }, - { - "cell_type": "markdown", - "id": "ab4a5347-a35f-4de9-bc57-3cf640424ff7", - "metadata": {}, - "source": [ - "# Stock Market Prediction Hands-On: Calculating Loss Functions (4/6)" - ] - }, - { - "cell_type": "markdown", - "id": "168f0d68-d4d5-48d3-8278-683fda9fd58a", - "metadata": {}, - "source": [ - "In previous segments, we successfully used linear regression for stock market prediction, guiding us to buy low and sell high, resulting in substantial profits. However, we are not content because there are still deviations between the model's predictions and the actual situation. This has caused us to buy at high points and sell at low points on several occasions. Following the principle that there's no harm in having more money, we aim to further optimize the model using a loss function. Today, let's first learn how to calculate the loss function.\n" - ] - }, - { - "cell_type": "markdown", - "id": "c46884ee-0a15-4666-a992-8f6fb7102744", - "metadata": {}, - "source": [ - "For regression tasks, there are three common types of loss functions. The first one is the Mean Squared Error (MSE), which measures the average of the squared differences between **predicted values** and **actual values** on the **training dataset** . The second one is the Mean Absolute Error (MAE), which measures the average of the absolute differences between **predicted values** and **actual values** on the **training dataset** ." - ] - }, - { - "cell_type": "markdown", - "id": "d0bac2a8-4505-4b86-a7fa-042f8018a622", - "metadata": {}, - "source": [ - "\"MAE-formula\"" - ] - }, - { - "cell_type": "markdown", - "id": "a8d48588-a8ea-4f00-a942-f04dd0598357", - "metadata": {}, - "source": [ - "So, let's go ahead and calculate the squared error and absolute error for each data point in the training set. The code is quite simple: we extract the labels and predicted results columns from the training set and use NumPy for some basic mathematical operations. The results are labeled as 'AE' and 'SE,'. As you can see, regardless of their magnitude, their values are never zero, meaning that there is always some difference between our predicted values and the actual values." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e9491a22", - "metadata": {}, - "outputs": [], - "source": [ - "df_train_pred = pd.DataFrame(y_train.values, \n", - " columns=['Actual'], index=y_train.index)\n", - "df_train_pred['Predicted'] = y_train_pred\n", - "df_train_pred = df_train_pred.reset_index()\n", - "sorted_df_train_pred = df_train_pred.sort_values(by='Date')\n", - "sorted_df_train_pred = sorted_df_train_pred.reset_index()\n", - "sorted_df_train_pred = sorted_df_train_pred.drop(columns=['index'])\n", - "sorted_df_train_pred['AE'] = \\\n", - " (sorted_df_train_pred['Predicted'] - \\\n", - " sorted_df_train_pred['Actual']).abs()\n", - "sorted_df_train_pred['SE'] = \\\n", - " np.square((sorted_df_train_pred['Predicted'] - \\\n", - " sorted_df_train_pred['Actual']))\n", - "sorted_df_train_pred" - ] - }, - { - "cell_type": "markdown", - "id": "9be6ebba-3fae-4f21-bba0-aa0e697ed4c9", - "metadata": {}, - "source": [ - "Furthermore, we can visualize how AE and SE change over time. It's evident that as time progresses, their values tend to increase, indicating that the results tested on the training set become more accurate as they approach 2005." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ced05c5d", - "metadata": {}, - "outputs": [], - "source": [ - "fig, axs = plt.subplots(1, 2, figsize=(7, 3))\n", - "\n", - "axs[0].plot(sorted_df_train_pred['AE'], color='blue')\n", - "axs[0].set_title('AE')\n", - "\n", - "axs[1].plot(sorted_df_train_pred['SE'], color='orange')\n", - "axs[1].set_title('SE')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a043402b-5f25-478c-bad3-a713693a3e59", - "metadata": {}, - "source": [ - "Finally, by taking the mean of the AE and SE columns, we obtain the results for the loss functions, MAE and MSE. With this, we have computed the values of the two most common loss functions for linear regression." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8fc62797", - "metadata": {}, - "outputs": [], - "source": [ - "mae = sorted_df_train_pred['AE'].mean()\n", - "mse = sorted_df_train_pred['SE'].mean()\n", - "print('mae = ', mae)\n", - "print('mse = ', mse)" - ] - }, - { - "cell_type": "markdown", - "id": "acea8cc2-7479-4e65-8812-6d143e2f075e", - "metadata": {}, - "source": [ - "You might have already noticed that these two loss functions seem quite similar to the MAE and MSE metrics we learned earlier. You're absolutely right, there is indeed significant overlap between the concepts of loss functions and evaluation metrics, but there are also key differences. In the next segment, we will thoroughly analyze these distinctions." - ] - }, - { - "cell_type": "markdown", - "id": "88b5f10b-9566-47b7-a95d-945c240b26fa", - "metadata": {}, - "source": [ - "\"meme-Einstein\"" - ] - }, - { - "cell_type": "markdown", - "id": "2604c01f-ebf7-4ccf-ac24-c6aa193d41d2", - "metadata": {}, - "source": [ - "# Stock Market Prediction Hands-On: Understanding Loss Functions (5/6)" - ] - }, - { - "cell_type": "markdown", - "id": "68374bcb-917b-4094-96e9-4812c83871d0", - "metadata": {}, - "source": [ - "\n", - "Loss functions and evaluation metrics share common ground in that they are both used to assess a model's predictive capabilities. In fact, terms like MAE or MSE are statistical concepts that can serve both as evaluation metrics and as loss functions, with identical mathematical calculations.\n", - "\n", - "The code blocks above compute MAE and MSE as loss functions, while the code blocks below calculate MAE and MSE as evaluation metrics. If the input data is the same, the results will be entirely identical." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6abe54c1", - "metadata": {}, - "outputs": [], - "source": [ - "mae = sorted_df_train_pred['AE'].mean()\n", - "mse = sorted_df_train_pred['SE'].mean()\n", - "print('mae = ', mae)\n", - "print('mse = ', mse)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3cf189b7", - "metadata": {}, - "outputs": [], - "source": [ - "mae2 = metrics.mean_absolute_error(y_train, y_train_pred)\n", - "mse2 = metrics.mean_squared_error(y_train, y_train_pred)\n", - "print('mae2 = ', mae2)\n", - "print('mse2 = ', mse2)" - ] - }, - { - "cell_type": "markdown", - "id": "ba0a0d59-4209-4cca-b372-6fbb76c3585f", - "metadata": {}, - "source": [ - "So, what are the key differences between loss functions and evaluation metrics? \n", - "\n", - "Firstly, evaluation metrics include concepts like R-squared and explained variance, which are not present in loss functions. \n", - "\n", - "Secondly, their purposes differ; loss functions are primarily used during model training to help the model gradually adjust its parameters to minimize prediction errors. In contrast, evaluation metrics are used to summarize and compare the performance of a trained model, to understand the overall effectiveness of the model, or to compare the performance differences between different models, guiding model selection.\n", - "\n", - "Thirdly, their optimization directions are different. With loss functions, the goal is typically to minimize them because smaller loss values imply that the predicted values are closer to the actual values. In contrast, for evaluation metrics, the goal is often to maximize their values; for example, in the case of R-squared, higher values indicate better model performance. This difference reflects the distinct roles of loss functions and evaluation metrics in machine learning tasks. \n", - "\n", - "Finally, as mentioned in the previous segment, loss functions are often calculated on the training set, while evaluation metrics are typically computed on the test set, with fewer instances of calculating them on the training set.\n" - ] - }, - { - "cell_type": "markdown", - "id": "71aeba1f-dbaf-4fcf-a1b9-161438d7c2f6", - "metadata": {}, - "source": [ - "\"Metric-formula\"\n", - "\n", - "\"loss-function-formula\"" - ] - }, - { - "cell_type": "markdown", - "id": "16b188b4-5e1e-49e4-87f8-494298335f75", - "metadata": {}, - "source": [ - "You're absolutely right, these differences might seem a bit overwhelming at first, but don't worry! In regression tasks, the distinctions between loss functions and evaluation metrics might not be as pronounced as in classification tasks. This was just a setup to introduce the concepts of evaluation metrics and loss functions.\n", - "\n", - "In classification tasks, we'll revisit the concepts of evaluation metrics and loss functions, and their differences will become clearer. As you gain a more comprehensive understanding of machine learning, these pieces of knowledge will gradually come together and become more straightforward.\n" - ] - }, - { - "cell_type": "markdown", - "id": "90c4494f-31fa-42bf-a11e-e2ca5ac81178", - "metadata": {}, - "source": [ - "# Stock Market Prediction Hands-On: Optimizing Models with Gradient Descent (6/6)" - ] - }, - { - "cell_type": "markdown", - "id": "7840fdc1-8da5-4bfc-9aa8-7cc5b83a8e32", - "metadata": {}, - "source": [ - "In previous segments, we used sklearn's LinearRegression to train on real U.S. stock market data, employed a linear regression model for stock price prediction, and calculated the model's loss functions. Another option for solving linear regression models is to use SGDRegressor. Here, SGD stands for Stochastic Gradient Descent, and you don't need to worry about its details for now; we'll be learning about it soon." - ] - }, - { - "cell_type": "markdown", - "id": "19462b49-a21c-4f9a-969a-7087d04f4a24", - "metadata": {}, - "source": [ - "\"stochastic-gradient-descent\"" - ] - }, - { - "cell_type": "markdown", - "id": "0ebe5104-a6b8-49e6-a43f-58789aac57bc", - "metadata": {}, - "source": [ - "The training process of SGDRegressor is iterative, and we can keep track of the changes in the loss function during training. This allows us to utilize the loss function to optimize the model.\n", - "\n", - "We start from the model's initial state and train for 100 epochs, which means 100 rounds of training, recording the loss function after each round in an array. Please note that our loss function is calculated on the training dataset." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4e92df97", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import SGDRegressor\n", - "\n", - "regressor = SGDRegressor(eta0=0.0005)\n", - "losses = []\n", - "epochs = 100\n", - "\n", - "for epoch in range(epochs):\n", - " regressor.partial_fit(X_train, y_train)\n", - " loss = (regressor.predict(X_train) - y_train).abs().mean()\n", - " losses.append(loss)" - ] - }, - { - "cell_type": "markdown", - "id": "6dbb08ce-a0e1-4a72-a836-bf9fe7ce3732", - "metadata": {}, - "source": [ - "We use Matplotlib to plot the results of the first 30 loss functions. As we can see, with an increase in epochs, the loss function gradually decreases. Moreover, the early epochs show a relatively rapid decline, while the later epochs exhibit a slower decrease." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e07e167d", - "metadata": {}, - "outputs": [], - "source": [ - "fig = plt.figure(figsize=(7, 4))\n", - "plt.plot(losses[:30], marker='o', markersize=10, color='green')\n", - "plt.xlabel('epoch')\n", - "plt.ylabel('loss')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5b5dc384-e15d-44f8-a0c0-ca8148241a3d", - "metadata": {}, - "source": [ - "\n", - "Furthermore, we plot the results of the loss function for all 100 training epochs. It's evident that the loss value keeps decreasing in the early epochs and only starts stabilizing after around 60 epochs.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1bc2ccd1", - "metadata": {}, - "outputs": [], - "source": [ - "fig = plt.figure(figsize=(7, 4))\n", - "plt.plot(losses, color='green')\n", - "plt.xlabel('epoch')\n", - "plt.ylabel('loss')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "4f48e207-c4df-433f-bd02-29629a129f50", - "metadata": {}, - "source": [ - "You might be curious about what's happening behind the scenes when the loss function of the SGDRegressor model decreases during training. Let's print the model's `coef_` attribute, which represents the coefficients of the linear model. Starting with the model obtained after one training epoch, we get the following results." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0b671069", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import SGDRegressor\n", - "\n", - "regressor1 = SGDRegressor(eta0=0.0005)\n", - "epochs = 1\n", - "\n", - "for epoch in range(epochs):\n", - " regressor1.partial_fit(X_train, y_train)\n", - " \n", - "regressor1.coef_" - ] - }, - { - "cell_type": "markdown", - "id": "1c48f74d-372f-491a-8f63-94628e0ad50b", - "metadata": {}, - "source": [ - "Next, here are the model parameters after 10 training epochs, and we obtain the following results.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0e15d9ef", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import SGDRegressor\n", - "\n", - "regressor10 = SGDRegressor(eta0=0.0005)\n", - "epochs = 10\n", - "\n", - "for epoch in range(epochs):\n", - " regressor10.partial_fit(X_train, y_train)\n", - " \n", - "regressor10.coef_" - ] - }, - { - "cell_type": "markdown", - "id": "04403b19-938a-4650-9d75-ef0c03ab3f58", - "metadata": {}, - "source": [ - "Finally, when we examine the model parameters after 100 training epochs, we observe that the linear model's parameters continue to change with an increase in training epochs." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8ff44ace", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import SGDRegressor\n", - "\n", - "regressor100 = SGDRegressor(eta0=0.0005)\n", - "epochs = 100\n", - "\n", - "for epoch in range(epochs):\n", - " regressor100.partial_fit(X_train, y_train)\n", - " \n", - "regressor100.coef_" - ] - }, - { - "cell_type": "markdown", - "id": "cb75974d-4f48-41d5-a7fd-e11734cffaca", - "metadata": {}, - "source": [ - "In essence, you can think of it this way: during the training process of the SGDRegressor model, the algorithm is continually trying to reduce the loss function. In other words, this is the direction of model optimization. Each training round of SGDRegressor results in a new model, which can yield a new loss function value on the training dataset. If the algorithm consistently finds a smaller loss function value in each iteration compared to the previous one, the model becomes incrementally more optimized with each round. Consequently, as the number of training epochs increases, the loss function tends to decrease until it stabilizes, and the model's parameters change along with it, ultimately achieving the optimal result." - ] - }, - { - "cell_type": "markdown", - "id": "c2a05c02-239e-4fdc-9f98-cbd963c58dd4", - "metadata": {}, - "source": [ - "\"dynamic-chart\"" - ] - }, - { - "cell_type": "markdown", - "id": "e57858b7-2458-4218-be99-2ea6666b25f2", - "metadata": {}, - "source": [ - "Of course, the explanation here might be a bit simplified, and we will provide more detailed answers in the upcoming gradient descent series. " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "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.10.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/open-machine-learning-jupyter-book/slides/ml-fundamentals/logistic-regression-condensed.ipynb b/open-machine-learning-jupyter-book/slides/ml-fundamentals/logistic-regression-condensed.ipynb new file mode 100644 index 0000000000..b547bdbff4 --- /dev/null +++ b/open-machine-learning-jupyter-book/slides/ml-fundamentals/logistic-regression-condensed.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "outputs": [], + "source": [ + "%%html\n", + "\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "0MRC0e0KhQ0S", + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Logistic Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Introduction\n", + "\n", + "\n", + "* In fact, logistic regression is a classification algorithm, unlike other regression models.\n", + "* Logistic Regression is very important for entering deep learning. \n", + "* After understanding this topic, you will be able to easily learning to Artificial Neural Network." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "LWd1UlMnhT2s", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Importing the libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "YvGPUQaHhXfL", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Sigmoid function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "def sigmoid(x):\n", + " return 1.0 / (1.0 + np.exp(-x))\n", + "\n", + "values = np.arange(-10, 10, 0.1)\n", + "\n", + "plt.plot(values, sigmoid(values))\n", + "plt.xlabel('x')\n", + "plt.ylabel('sigmoid(x)')\n", + "plt.title('Sigmoid Function in Matplotlib')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "K1VMqkGvhc3-", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Importing the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "M52QDmyzhh9s", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "dataset = pd.read_csv('../../assets/data/Social_Network_Ads.csv')\n", + "X = dataset.iloc[:, :-1].values\n", + "y = dataset.iloc[:, -1].values\n", + "\n", + "dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "YvxIPVyMhmKp", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Splitting the dataset into the Training set and Test set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "AVzJWAXIhxoC", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "kW3c7UYih0hT", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Feature Scaling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "9fQlDPKCh8sc", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "sc = StandardScaler()\n", + "X_train = sc.fit_transform(X_train)\n", + "X_test = sc.transform(X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "bb6jCOCQiAmP", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Training the Logistic Regression model on the Training set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 103 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2125, + "status": "ok", + "timestamp": 1588265315505, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "e0pFVAmciHQs", + "outputId": "67f64468-abdb-4fe7-cce9-de0037119610", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "classifier = LogisticRegression(random_state = 0)\n", + "classifier.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "yyxW5b395mR2", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Predicting a new result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2118, + "status": "ok", + "timestamp": 1588265315505, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "f8YOXsQy58rP", + "outputId": "2e1b0063-548e-4924-cf3a-93a79d97e35e", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "print(classifier.predict(sc.transform([[30, 87000], [65, 990000]])))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "vKYVQH-l5NpE", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Predicting the Test set results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2112, + "status": "ok", + "timestamp": 1588265315506, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "p6VMTb2O4hwM", + "outputId": "a4f03a97-2942-45cd-f735-f4063277a96c", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "y_pred = classifier.predict(X_test)\n", + "print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)), 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "h4Hwj34ziWQW", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Making the Confusion Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 68 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 2107, + "status": "ok", + "timestamp": 1588265315506, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "D6bpZwUiiXic", + "outputId": "f202fcb3-5882-4d93-e5df-50791185067e", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.metrics import confusion_matrix, accuracy_score\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "print(cm)\n", + "accuracy_score(y_test, y_pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "6OMC_P0diaoD", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Visualising the Training set results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 349 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 23189, + "status": "ok", + "timestamp": 1588265336596, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "_NOjKvZRid5l", + "outputId": "6fa60701-9aa4-46f2-a6aa-0f9b0aad62b3", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from matplotlib.colors import ListedColormap\n", + "X_set, y_set = sc.inverse_transform(X_train), y_train\n", + "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 10, stop = X_set[:, 0].max() + 10, step = 0.5),\n", + " np.arange(start = X_set[:, 1].min() - 1000, stop = X_set[:, 1].max() + 1000, step = 0.5))\n", + "plt.contourf(X1, X2, classifier.predict(sc.transform(np.array([X1.ravel(), X2.ravel()]).T)).reshape(X1.shape),\n", + " alpha = 0.75, cmap = ListedColormap(('red', 'green')))\n", + "plt.xlim(X1.min(), X1.max())\n", + "plt.ylim(X2.min(), X2.max())\n", + "for i, j in enumerate(np.unique(y_set)):\n", + " plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j)\n", + "plt.title('Logistic Regression (Training set)')\n", + "plt.xlabel('Age')\n", + "plt.ylabel('Estimated Salary')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "SZ-j28aPihZx", + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Visualising the Test set results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 349 + }, + "colab_type": "code", + "executionInfo": { + "elapsed": 43807, + "status": "ok", + "timestamp": 1588265357223, + "user": { + "displayName": "Hadelin de Ponteves", + "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GhEuXdT7eQweUmRPW8_laJuPggSK6hfvpl5a6WBaA=s64", + "userId": "15047218817161520419" + }, + "user_tz": -240 + }, + "id": "qeTjz2vDilAC", + "outputId": "00fb10bc-c726-46b8-8eaa-c5c6b584aa54", + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from matplotlib.colors import ListedColormap\n", + "X_set, y_set = sc.inverse_transform(X_test), y_test\n", + "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 10, stop = X_set[:, 0].max() + 10, step = 0.5),\n", + " np.arange(start = X_set[:, 1].min() - 1000, stop = X_set[:, 1].max() + 1000, step = 0.5))\n", + "plt.contourf(X1, X2, classifier.predict(sc.transform(np.array([X1.ravel(), X2.ravel()]).T)).reshape(X1.shape),\n", + " alpha = 0.75, cmap = ListedColormap(('red', 'green')))\n", + "plt.xlim(X1.min(), X1.max())\n", + "plt.ylim(X2.min(), X2.max())\n", + "for i, j in enumerate(np.unique(y_set)):\n", + " plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j)\n", + "plt.title('Logistic Regression (Test set)')\n", + "plt.xlabel('Age')\n", + "plt.ylabel('Estimated Salary')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Linear Regression v.s. Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "from sklearn.datasets import make_classification\n", + "\n", + "X, y = make_classification(\n", + " n_features=2, n_redundant=0, n_informative=2, n_clusters_per_class=1, random_state=12\n", + ")\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n", + "\n", + "plt.scatter(X[:, 0], X[:, 1], c=y)\n", + "\n", + "plt.plot([-2.0, 0], [1.2, -1.3])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "classifier = LogisticRegression(random_state = 0)\n", + "classifier.fit(X_train, y_train)\n", + "\n", + "classifier.__dict__\n", + "\n", + "print(1.4/2.4)\n", + "\n", + "print(1.3/2.4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "from sklearn.metrics import confusion_matrix, accuracy_score\n", + "\n", + "y_pred = classifier.predict(X_test)\n", + "\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "print(cm)\n", + "accuracy_score(y_test, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [], + "source": [ + "classifier.coef_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Assignment - 1\n", + "\n", + "- Build classification models：Predict the price range" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Assignment - 2\n", + "\n", + "- Logistic Regression from scratch\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "colab": { + "authorship_tag": "ABX9TyOsvB/iqEjYj3VN6C/JbvkE", + "collapsed_sections": [], + "machine_shape": "hm", + "name": "logistic_regression.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/tutorials/code-for-videos/introduction-to-machine-learning.ipynb b/tutorials/introduction-to-machine-learning.ipynb similarity index 100% rename from tutorials/code-for-videos/introduction-to-machine-learning.ipynb rename to tutorials/introduction-to-machine-learning.ipynb diff --git a/tutorials/code-for-videos/linear-regression-loss-function.ipynb b/tutorials/linear-regression-loss-function.ipynb similarity index 100% rename from tutorials/code-for-videos/linear-regression-loss-function.ipynb rename to tutorials/linear-regression-loss-function.ipynb diff --git a/tutorials/code-for-videos/metrics-linear-regression-diabetes.ipynb b/tutorials/metrics-linear-regression-diabetes.ipynb similarity index 99% rename from tutorials/code-for-videos/metrics-linear-regression-diabetes.ipynb rename to tutorials/metrics-linear-regression-diabetes.ipynb index ab59ade1ef..79582e73ef 100644 --- a/tutorials/code-for-videos/metrics-linear-regression-diabetes.ipynb +++ b/tutorials/metrics-linear-regression-diabetes.ipynb @@ -9,13 +9,6 @@ "# **Linear Regression - SKLearn Diabetes Dataset**" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Can AI predict diabetes? Test set training set (1/5)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1547,13 +1540,6 @@ "However, this method is obviously too primitive. Is there a better way to evaluate the quality of the model?" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Can AI predict diabetes? Illustrated evaluation indicators (2/5)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1588,13 +1574,6 @@ "***" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Can AI predict diabetes? Achieve evaluation metrics (3/5)" - ] - }, { "cell_type": "markdown", "metadata": { @@ -1772,13 +1751,6 @@ "print('r_squared_sklearn = ', r_squared_sklearn)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Can AI predict diabetes? Detailed explanation of MAPE (4/5)\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -2007,13 +1979,6 @@ "print(summary_model)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Can AI predict diabetes? Detailed explanation of R-squared (5/5)" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/tutorials/code-for-videos/multiple-linear-regression.ipynb b/tutorials/multiple-linear-regression.ipynb similarity index 100% rename from tutorials/code-for-videos/multiple-linear-regression.ipynb rename to tutorials/multiple-linear-regression.ipynb diff --git a/tutorials/code-for-videos/polynomial_regression.ipynb b/tutorials/polynomial_regression.ipynb similarity index 100% rename from tutorials/code-for-videos/polynomial_regression.ipynb rename to tutorials/polynomial_regression.ipynb diff --git a/tutorials/code-for-videos/simple-linear-regression.ipynb b/tutorials/simple-linear-regression.ipynb similarity index 100% rename from tutorials/code-for-videos/simple-linear-regression.ipynb rename to tutorials/simple-linear-regression.ipynb