From 2e7277ce8fbbc37fcfbe62dc5bf6081835c683a5 Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Tue, 6 Jul 2021 19:28:37 +0700
Subject: [PATCH 1/8] docs: translate 1-Tools (WIP)
---
.../1-Tools/translations/README.id.md | 207 ++++++++++++++++++
1 file changed, 207 insertions(+)
create mode 100644 2-Regression/1-Tools/translations/README.id.md
diff --git a/2-Regression/1-Tools/translations/README.id.md b/2-Regression/1-Tools/translations/README.id.md
new file mode 100644
index 000000000..ca32b820e
--- /dev/null
+++ b/2-Regression/1-Tools/translations/README.id.md
@@ -0,0 +1,207 @@
+# Get started with Python and Scikit-learn for regression models
+
+
+
+> Catatan sketsa oleh [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Kuis Pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/9/)
+## Pembukaan
+
+Dalam keempat pelajaran ini, kamu akan belajar bagaimana membangun model regresi. Kita akan berdiskusi apa fungsi model tersebut dalam sejenak. Tetapi sebelum kamu melakukan apapun, pastikan bahwa kamu sudah mempunyai alat-alat yang diperlukan untuk memulai!
+
+Dalam pelajaran ini, kamu akan belajar bagaimana untuk:
+
+- Konfigurasi komputermu untuk tugas pembelajaran.
+- Bekerja dengan Jupyter notebooks.
+- Menggunakan Scikit-learn, termasuk instalasi.
+- Menjelajahi regresi linear dengan latihan *hands-on*.
+
+
+## Instalasi dan konfigurasi
+
+[](https://youtu.be/7EXd4_ttIuw "Menggunakan Python dalam Visual Studio Code")
+
+> ๐ฅ Klik foto di atas untuk sebuah video: menggunakan Python dalam VS Code
+
+1. **Pasang Python**. Pastikan bahwa [Python](https://www.python.org/downloads/) telah dipasang di komputermu. Kamu akan menggunakan Python untuk banyak tugas *data science* dan *machine learning*. Kebanyakan sistem komputer sudah diinstal dengan Python. Adapula *[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa)* yang berguna untuk membantu proses pemasangan untuk beberapa pengguna.
+
+ Beberapa penggunaan Python memerlukan satu versi perangkat lunak tersebut, sedangkan beberapa penggunaan lainnya mungkin memerlukan versi Python yang beda lagi. Oleh sebab itulah akan sangat berguna untuk bekerja dalam sebuah *[virtual environment](https://docs.python.org/3/library/venv.html)* (lingkungan virtual).
+
+2. **Pasang Visual Studio Code**. Pastikan kamu sudah memasangkan Visual Studio Code di komputermu. Ikuti instruksi-instruksi ini untuk [memasangkan Visual Studio Code](https://code.visualstudio.com/) untuk instalasi dasar. Kamu akan menggunakan Python dalam Visual Studio Code dalam kursus ini, jadi kamu mungkin akan ingin mencari tahu cara [mengkonfigurasi Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-15963-cxa) untuk menggunakan Python.
+
+ > Nyamankan diri dengan Python dengan mengerjakan [koleksi modul pembelajaran ini](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-15963-cxa)
+
+3. **Pasang Scikit-learn**, dengan mengikuti [instruksi di sini](https://scikit-learn.org/stable/install.html). Karena harus dipastikan bahwa kamu sedang menggunakan Python 3, kami anjurkan kamu menggunakan sebuah *virtual environment*. Ingatlah juga bahwa jika kamu ingin memasangkan ini di sebuah M1 Mac, ada instruksi khusus dalam laman yang ditautkan di atas.
+
+4. **Pasang Jupyter Notebook**. Kamu akan harus [memasang paket Jupyter](https://pypi.org/project/jupyter/).
+
+## Lingkungan penulisan ML-mu
+
+Kamu akan menggunakan ***notebooks*** untuk bekerja dengan kode Python-mu dan membuat model *machine learning*-mu. Jenis file ini adalah alat yang sering digunakan *data scientists* dan dapat diidentifikasikan dengan akhiran/ekstensi `.ipynb`.
+
+Notebooks are an interactive environment that allow the developer to both code and add notes and write documentation around the code which is quite helpful for experimental or research-oriented projects.
+
+### Exercise - work with a notebook
+
+In this folder, you will find the file _notebook.ipynb_.
+
+1. Open _notebook.ipynb_ in Visual Studio Code.
+
+ A Jupyter server will start with Python 3+ started. You will find areas of the notebook that can be `run`, pieces of code. You can run a code block, by selecting the icon that looks like a play button.
+
+1. Select the `md` icon and add a bit of markdown, and the following text **# Welcome to your notebook**.
+
+ Next, add some Python code.
+
+1. Type **print('hello notebook')** in the code block.
+1. Select the arrow to run the code.
+
+ You should see the printed statement:
+
+ ```output
+ hello notebook
+ ```
+
+
+
+You can interleaf your code with comments to self-document the notebook.
+
+โ
Think for a minute how different a web developer's working environment is versus that of a data scientist.
+
+## Up and running with Scikit-learn
+
+Now that Python is set up in your local environment, and you are comfortable with Jupyter notebooks, let's get equally comfortable with Scikit-learn (pronounce it `sci` as in `science`). Scikit-learn provides an [extensive API](https://scikit-learn.org/stable/modules/classes.html#api-ref) to help you perform ML tasks.
+
+According to their [website](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection and evaluation, and many other utilities."
+
+In this course, you will use Scikit-learn and other tools to build machine learning models to perform what we call 'traditional machine learning' tasks. We have deliberately avoided neural networks and deep learning, as they are better covered in our forthcoming 'AI for Beginners' curriculum.
+
+Scikit-learn makes it straightforward to build models and evaluate them for use. It is primarily focused on using numeric data and contains several ready-made datasets for use as learning tools. It also includes pre-built models for students to try. Let's explore the process of loading prepackaged data and using a built in estimator first ML model with Scikit-learn with some basic data.
+
+## Exercise - your first Scikit-learn notebook
+
+> This tutorial was inspired by the [linear regression example](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) on Scikit-learn's web site.
+
+In the _notebook.ipynb_ file associated to this lesson, clear out all the cells by pressing the 'trash can' icon.
+
+In this section, you will work with a small dataset about diabetes that is built into Scikit-learn for learning purposes. Imagine that you wanted to test a treatment for diabetic patients. Machine Learning models might help you determine which patients would respond better to the treatment, based on combinations of variables. Even a very basic regression model, when visualized, might show information about variables that would help you organize your theoretical clinical trials.
+
+โ
There are many types of regression methods, and which one you pick depends on the answer you're looking for. If you want to predict the probable height for a person of a given age, you'd use linear regression, as you're seeking a **numeric value**. If you're interested in discovering whether a type of cuisine should be considered vegan or not, you're looking for a **category assignment** so you would use logistic regression. You'll learn more about logistic regression later. Think a bit about some questions you can ask of data, and which of these methods would be more appropriate.
+
+Let's get started on this task.
+
+### Import libraries
+
+For this task we will import some libraries:
+
+- **matplotlib**. It's a useful [graphing tool](https://matplotlib.org/) and we will use it to create a line plot.
+- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) is a useful library for handling numeric data in Python.
+- **sklearn**. This is the Scikit-learn library.
+
+Import some libraries to help with your tasks.
+
+1. Add imports by typing the following code:
+
+ ```python
+ import matplotlib.pyplot as plt
+ import numpy as np
+ from sklearn import datasets, linear_model, model_selection
+ ```
+
+ Above you are importing `matplottlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
+
+### The diabetes dataset
+
+The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
+
+age: age in years
+bmi: body mass index
+bp: average blood pressure
+s1 tc: T-Cells (a type of white blood cells)
+
+โ
This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
+
+Now, load up the X and y data.
+
+> ๐ Remember, this is supervised learning, and we need a named 'y' target.
+
+In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y` will be the regression target.
+
+1. Add some print commands to show the shape of the data matrix and its first element:
+
+ ```python
+ X, y = datasets.load_diabetes(return_X_y=True)
+ print(X.shape)
+ print(X[0])
+ ```
+
+ What you are getting back as a response, is a tuple. What you are doing is to assign the two first values of the tuple to `X` and `y` respectively. Learn more [about tuples](https://wikipedia.org/wiki/Tuple).
+
+ You can see that this data has 442 items shaped in arrays of 10 elements:
+
+ ```text
+ (442, 10)
+ [ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
+ -0.04340085 -0.00259226 0.01990842 -0.01764613]
+ ```
+
+ โ
Think a bit about the relationship between the data and the regression target. Linear regression predicts relationships between feature X and target variable y. Can you find the [target](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for the diabetes dataset in the documentation? What is this dataset demonstrating, given that target?
+
+2. Next, select a portion of this dataset to plot by arranging it into a new array using numpy's `newaxis` function. We are going to use linear regression to generate a line between values in this data, according to a pattern it determines.
+
+ ```python
+ X = X[:, np.newaxis, 2]
+ ```
+
+ โ
At any time, print out the data to check its shape.
+
+3. Now that you have data ready to be plotted, you can see if a machine can help determine a logical split between the numbers in this dataset. To do this, you need to split both the data (X) and the target (y) into test and training sets. Scikit-learn has a straightforward way to do this; you can split your test data at a given point.
+
+ ```python
+ X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
+ ```
+
+4. Now you are ready to train your model! Load up the linear regression model and train it with your X and y training sets using `model.fit()`:
+
+ ```python
+ model = linear_model.LinearRegression()
+ model.fit(X_train, y_train)
+ ```
+
+ โ
`model.fit()` is a function you'll see in many ML libraries such as TensorFlow
+
+5. Then, create a prediction using test data, using the function `predict()`. This will be used to draw the line between data groups
+
+ ```python
+ y_pred = model.predict(X_test)
+ ```
+
+6. Now it's time to show the data in a plot. Matplotlib is a very useful tool for this task. Create a scatterplot of all the X and y test data, and use the prediction to draw a line in the most appropriate place, between the model's data groupings.
+
+ ```python
+ plt.scatter(X_test, y_test, color='black')
+ plt.plot(X_test, y_pred, color='blue', linewidth=3)
+ plt.show()
+ ```
+
+ 
+
+ โ
Think a bit about what's going on here. A straight line is running through many small dots of data, but what is it doing exactly? Can you see how you should be able to use this line to predict where a new, unseen data point should fit in relationship to the plot's y axis? Try to put into words the practical use of this model.
+
+Congratulations, you built your first linear regression model, created a prediction with it, and displayed it in a plot!
+
+---
+## ๐Challenge
+
+Plot a different variable from this dataset. Hint: edit this line: `X = X[:, np.newaxis, 2]`. Given this dataset's target, what are you able to discover about the progression of diabetes as a disease?
+## [Post-lecture quiz](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
+
+## Review & Self Study
+
+In this tutorial, you worked with simple linear regression, rather than univariate or multiple linear regression. Read a little about the differences between these methods, or take a look at [this video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
+
+Read more about the concept of regression and think about what kinds of questions can be answered by this technique. Take this [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) to deepen your understanding.
+
+## Assignment
+
+[A different dataset](assignment.md)
From 8ac4c6700d9b53178ceafba0d13c6aee915f3ad5 Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Tue, 6 Jul 2021 19:28:37 +0700
Subject: [PATCH 2/8] Add Indonesian translation for 2-Regression/1-Tools (WIP)
---
.../1-Tools/translations/README.id.md | 207 ++++++++++++++++++
1 file changed, 207 insertions(+)
create mode 100644 2-Regression/1-Tools/translations/README.id.md
diff --git a/2-Regression/1-Tools/translations/README.id.md b/2-Regression/1-Tools/translations/README.id.md
new file mode 100644
index 000000000..ca32b820e
--- /dev/null
+++ b/2-Regression/1-Tools/translations/README.id.md
@@ -0,0 +1,207 @@
+# Get started with Python and Scikit-learn for regression models
+
+
+
+> Catatan sketsa oleh [Tomomi Imura](https://www.twitter.com/girlie_mac)
+
+## [Kuis Pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/9/)
+## Pembukaan
+
+Dalam keempat pelajaran ini, kamu akan belajar bagaimana membangun model regresi. Kita akan berdiskusi apa fungsi model tersebut dalam sejenak. Tetapi sebelum kamu melakukan apapun, pastikan bahwa kamu sudah mempunyai alat-alat yang diperlukan untuk memulai!
+
+Dalam pelajaran ini, kamu akan belajar bagaimana untuk:
+
+- Konfigurasi komputermu untuk tugas pembelajaran.
+- Bekerja dengan Jupyter notebooks.
+- Menggunakan Scikit-learn, termasuk instalasi.
+- Menjelajahi regresi linear dengan latihan *hands-on*.
+
+
+## Instalasi dan konfigurasi
+
+[](https://youtu.be/7EXd4_ttIuw "Menggunakan Python dalam Visual Studio Code")
+
+> ๐ฅ Klik foto di atas untuk sebuah video: menggunakan Python dalam VS Code
+
+1. **Pasang Python**. Pastikan bahwa [Python](https://www.python.org/downloads/) telah dipasang di komputermu. Kamu akan menggunakan Python untuk banyak tugas *data science* dan *machine learning*. Kebanyakan sistem komputer sudah diinstal dengan Python. Adapula *[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa)* yang berguna untuk membantu proses pemasangan untuk beberapa pengguna.
+
+ Beberapa penggunaan Python memerlukan satu versi perangkat lunak tersebut, sedangkan beberapa penggunaan lainnya mungkin memerlukan versi Python yang beda lagi. Oleh sebab itulah akan sangat berguna untuk bekerja dalam sebuah *[virtual environment](https://docs.python.org/3/library/venv.html)* (lingkungan virtual).
+
+2. **Pasang Visual Studio Code**. Pastikan kamu sudah memasangkan Visual Studio Code di komputermu. Ikuti instruksi-instruksi ini untuk [memasangkan Visual Studio Code](https://code.visualstudio.com/) untuk instalasi dasar. Kamu akan menggunakan Python dalam Visual Studio Code dalam kursus ini, jadi kamu mungkin akan ingin mencari tahu cara [mengkonfigurasi Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-15963-cxa) untuk menggunakan Python.
+
+ > Nyamankan diri dengan Python dengan mengerjakan [koleksi modul pembelajaran ini](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-15963-cxa)
+
+3. **Pasang Scikit-learn**, dengan mengikuti [instruksi di sini](https://scikit-learn.org/stable/install.html). Karena harus dipastikan bahwa kamu sedang menggunakan Python 3, kami anjurkan kamu menggunakan sebuah *virtual environment*. Ingatlah juga bahwa jika kamu ingin memasangkan ini di sebuah M1 Mac, ada instruksi khusus dalam laman yang ditautkan di atas.
+
+4. **Pasang Jupyter Notebook**. Kamu akan harus [memasang paket Jupyter](https://pypi.org/project/jupyter/).
+
+## Lingkungan penulisan ML-mu
+
+Kamu akan menggunakan ***notebooks*** untuk bekerja dengan kode Python-mu dan membuat model *machine learning*-mu. Jenis file ini adalah alat yang sering digunakan *data scientists* dan dapat diidentifikasikan dengan akhiran/ekstensi `.ipynb`.
+
+Notebooks are an interactive environment that allow the developer to both code and add notes and write documentation around the code which is quite helpful for experimental or research-oriented projects.
+
+### Exercise - work with a notebook
+
+In this folder, you will find the file _notebook.ipynb_.
+
+1. Open _notebook.ipynb_ in Visual Studio Code.
+
+ A Jupyter server will start with Python 3+ started. You will find areas of the notebook that can be `run`, pieces of code. You can run a code block, by selecting the icon that looks like a play button.
+
+1. Select the `md` icon and add a bit of markdown, and the following text **# Welcome to your notebook**.
+
+ Next, add some Python code.
+
+1. Type **print('hello notebook')** in the code block.
+1. Select the arrow to run the code.
+
+ You should see the printed statement:
+
+ ```output
+ hello notebook
+ ```
+
+
+
+You can interleaf your code with comments to self-document the notebook.
+
+โ
Think for a minute how different a web developer's working environment is versus that of a data scientist.
+
+## Up and running with Scikit-learn
+
+Now that Python is set up in your local environment, and you are comfortable with Jupyter notebooks, let's get equally comfortable with Scikit-learn (pronounce it `sci` as in `science`). Scikit-learn provides an [extensive API](https://scikit-learn.org/stable/modules/classes.html#api-ref) to help you perform ML tasks.
+
+According to their [website](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection and evaluation, and many other utilities."
+
+In this course, you will use Scikit-learn and other tools to build machine learning models to perform what we call 'traditional machine learning' tasks. We have deliberately avoided neural networks and deep learning, as they are better covered in our forthcoming 'AI for Beginners' curriculum.
+
+Scikit-learn makes it straightforward to build models and evaluate them for use. It is primarily focused on using numeric data and contains several ready-made datasets for use as learning tools. It also includes pre-built models for students to try. Let's explore the process of loading prepackaged data and using a built in estimator first ML model with Scikit-learn with some basic data.
+
+## Exercise - your first Scikit-learn notebook
+
+> This tutorial was inspired by the [linear regression example](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) on Scikit-learn's web site.
+
+In the _notebook.ipynb_ file associated to this lesson, clear out all the cells by pressing the 'trash can' icon.
+
+In this section, you will work with a small dataset about diabetes that is built into Scikit-learn for learning purposes. Imagine that you wanted to test a treatment for diabetic patients. Machine Learning models might help you determine which patients would respond better to the treatment, based on combinations of variables. Even a very basic regression model, when visualized, might show information about variables that would help you organize your theoretical clinical trials.
+
+โ
There are many types of regression methods, and which one you pick depends on the answer you're looking for. If you want to predict the probable height for a person of a given age, you'd use linear regression, as you're seeking a **numeric value**. If you're interested in discovering whether a type of cuisine should be considered vegan or not, you're looking for a **category assignment** so you would use logistic regression. You'll learn more about logistic regression later. Think a bit about some questions you can ask of data, and which of these methods would be more appropriate.
+
+Let's get started on this task.
+
+### Import libraries
+
+For this task we will import some libraries:
+
+- **matplotlib**. It's a useful [graphing tool](https://matplotlib.org/) and we will use it to create a line plot.
+- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) is a useful library for handling numeric data in Python.
+- **sklearn**. This is the Scikit-learn library.
+
+Import some libraries to help with your tasks.
+
+1. Add imports by typing the following code:
+
+ ```python
+ import matplotlib.pyplot as plt
+ import numpy as np
+ from sklearn import datasets, linear_model, model_selection
+ ```
+
+ Above you are importing `matplottlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
+
+### The diabetes dataset
+
+The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
+
+age: age in years
+bmi: body mass index
+bp: average blood pressure
+s1 tc: T-Cells (a type of white blood cells)
+
+โ
This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
+
+Now, load up the X and y data.
+
+> ๐ Remember, this is supervised learning, and we need a named 'y' target.
+
+In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y` will be the regression target.
+
+1. Add some print commands to show the shape of the data matrix and its first element:
+
+ ```python
+ X, y = datasets.load_diabetes(return_X_y=True)
+ print(X.shape)
+ print(X[0])
+ ```
+
+ What you are getting back as a response, is a tuple. What you are doing is to assign the two first values of the tuple to `X` and `y` respectively. Learn more [about tuples](https://wikipedia.org/wiki/Tuple).
+
+ You can see that this data has 442 items shaped in arrays of 10 elements:
+
+ ```text
+ (442, 10)
+ [ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
+ -0.04340085 -0.00259226 0.01990842 -0.01764613]
+ ```
+
+ โ
Think a bit about the relationship between the data and the regression target. Linear regression predicts relationships between feature X and target variable y. Can you find the [target](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for the diabetes dataset in the documentation? What is this dataset demonstrating, given that target?
+
+2. Next, select a portion of this dataset to plot by arranging it into a new array using numpy's `newaxis` function. We are going to use linear regression to generate a line between values in this data, according to a pattern it determines.
+
+ ```python
+ X = X[:, np.newaxis, 2]
+ ```
+
+ โ
At any time, print out the data to check its shape.
+
+3. Now that you have data ready to be plotted, you can see if a machine can help determine a logical split between the numbers in this dataset. To do this, you need to split both the data (X) and the target (y) into test and training sets. Scikit-learn has a straightforward way to do this; you can split your test data at a given point.
+
+ ```python
+ X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
+ ```
+
+4. Now you are ready to train your model! Load up the linear regression model and train it with your X and y training sets using `model.fit()`:
+
+ ```python
+ model = linear_model.LinearRegression()
+ model.fit(X_train, y_train)
+ ```
+
+ โ
`model.fit()` is a function you'll see in many ML libraries such as TensorFlow
+
+5. Then, create a prediction using test data, using the function `predict()`. This will be used to draw the line between data groups
+
+ ```python
+ y_pred = model.predict(X_test)
+ ```
+
+6. Now it's time to show the data in a plot. Matplotlib is a very useful tool for this task. Create a scatterplot of all the X and y test data, and use the prediction to draw a line in the most appropriate place, between the model's data groupings.
+
+ ```python
+ plt.scatter(X_test, y_test, color='black')
+ plt.plot(X_test, y_pred, color='blue', linewidth=3)
+ plt.show()
+ ```
+
+ 
+
+ โ
Think a bit about what's going on here. A straight line is running through many small dots of data, but what is it doing exactly? Can you see how you should be able to use this line to predict where a new, unseen data point should fit in relationship to the plot's y axis? Try to put into words the practical use of this model.
+
+Congratulations, you built your first linear regression model, created a prediction with it, and displayed it in a plot!
+
+---
+## ๐Challenge
+
+Plot a different variable from this dataset. Hint: edit this line: `X = X[:, np.newaxis, 2]`. Given this dataset's target, what are you able to discover about the progression of diabetes as a disease?
+## [Post-lecture quiz](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
+
+## Review & Self Study
+
+In this tutorial, you worked with simple linear regression, rather than univariate or multiple linear regression. Read a little about the differences between these methods, or take a look at [this video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
+
+Read more about the concept of regression and think about what kinds of questions can be answered by this technique. Take this [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) to deepen your understanding.
+
+## Assignment
+
+[A different dataset](assignment.md)
From 9d2463384b7a3380b8addc8ff1e2f8efadaa7fcb Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Tue, 6 Jul 2021 21:14:18 +0700
Subject: [PATCH 3/8] Add Indonesian translation for 2-Regression/1-Tools
---
.../1-Tools/translations/README.id.md | 135 +++++++++---------
1 file changed, 68 insertions(+), 67 deletions(-)
diff --git a/2-Regression/1-Tools/translations/README.id.md b/2-Regression/1-Tools/translations/README.id.md
index ca32b820e..b29301e2a 100644
--- a/2-Regression/1-Tools/translations/README.id.md
+++ b/2-Regression/1-Tools/translations/README.id.md
@@ -1,4 +1,4 @@
-# Get started with Python and Scikit-learn for regression models
+# Memulai dengan Python dan Scikit-learn untuk model regresi
@@ -23,7 +23,7 @@ Dalam pelajaran ini, kamu akan belajar bagaimana untuk:
> ๐ฅ Klik foto di atas untuk sebuah video: menggunakan Python dalam VS Code
-1. **Pasang Python**. Pastikan bahwa [Python](https://www.python.org/downloads/) telah dipasang di komputermu. Kamu akan menggunakan Python untuk banyak tugas *data science* dan *machine learning*. Kebanyakan sistem komputer sudah diinstal dengan Python. Adapula *[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa)* yang berguna untuk membantu proses pemasangan untuk beberapa pengguna.
+1. **Pasang Python**. Pastikan bahwa [Python](https://www.python.org/downloads/) telah dipasang di komputermu. Kamu akan menggunakan Python untuk banyak tugas *data science* dan *machine learning*. Python sudah dipasang di kebanyakan sistem komputer. Adapula *[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa)* yang berguna untuk membantu proses pemasangan untuk beberapa pengguna.
Beberapa penggunaan Python memerlukan satu versi perangkat lunak tersebut, sedangkan beberapa penggunaan lainnya mungkin memerlukan versi Python yang beda lagi. Oleh sebab itulah akan sangat berguna untuk bekerja dalam sebuah *[virtual environment](https://docs.python.org/3/library/venv.html)* (lingkungan virtual).
@@ -39,68 +39,70 @@ Dalam pelajaran ini, kamu akan belajar bagaimana untuk:
Kamu akan menggunakan ***notebooks*** untuk bekerja dengan kode Python-mu dan membuat model *machine learning*-mu. Jenis file ini adalah alat yang sering digunakan *data scientists* dan dapat diidentifikasikan dengan akhiran/ekstensi `.ipynb`.
-Notebooks are an interactive environment that allow the developer to both code and add notes and write documentation around the code which is quite helpful for experimental or research-oriented projects.
+*Notebook* adalah sebuah lingkungan interaktif yang memungkinkan seorang *developer* untuk menulis kode, catatan, dan dokumentasi mengenai kode tersebut sehingga menjadi sangat berguna untuk proyek eksperimental ataupun riset.
-### Exercise - work with a notebook
+### Latihan - bekerja dengan sebuah *notebook*
-In this folder, you will find the file _notebook.ipynb_.
+Dalam folder ini, kamu akan menemukan file _notebook.ipynb_.
-1. Open _notebook.ipynb_ in Visual Studio Code.
+1. Buka _notebook.ipynb_ dalam Visual Studio Code.
- A Jupyter server will start with Python 3+ started. You will find areas of the notebook that can be `run`, pieces of code. You can run a code block, by selecting the icon that looks like a play button.
+ Sebuah server Jupyter akan mulai dengan Python 3+. Kamu akan menemukan bagian-bagian *notebook* yang dapat di-`run` (dijalankan). Bagian-bagian tersebut adalah carikan-carikan kode. Kamu bisa menjalankan secarik kode dengan mengklik tombol โถ.
-1. Select the `md` icon and add a bit of markdown, and the following text **# Welcome to your notebook**.
+2. Pilih ikon `md` dan tambahlah sedikit *markdown*: **# Selamat datang di *notebook* saya!**
- Next, add some Python code.
+ Lalu, tambahlah sedikit kode Python.
-1. Type **print('hello notebook')** in the code block.
-1. Select the arrow to run the code.
+3. Ketik **print('hello notebook')** dalam blok kode.
- You should see the printed statement:
+4. Klik โถ untuk menjalankan kode.
+
+ Hasilnya harusnya ini:
```output
hello notebook
```
-
+
+
+Kamu bisa menyelipkan catatan-catatan antara kodemu untuk mendokumentasi *notebook*-nya.
-You can interleaf your code with comments to self-document the notebook.
+โ
Pikirkanlah sejenak bagaimana lingkungan seorang *web developer* berbeda dengan lingkungan seorang *data scientist*.
-โ
Think for a minute how different a web developer's working environment is versus that of a data scientist.
+## Berjalan dengan Scikit-learn
-## Up and running with Scikit-learn
+Sekarang, Python sudah siap dalam lingkungan lokalmu, dan kamu sudah nyaman bekerja dengan *Jupyter notebook*. Marilah membiasakan diri dengan Scikit-learn (dilafalkan `saikit lern`; huruf `e` dalam `lern` seperti `e` dalam kata `Perancis`). Scikit-learn menyediakan sebuah [API ekstensif](https://scikit-learn.org/stable/modules/classes.html#api-ref) untuk membantu kamu mengerjakan tugas ML.
-Now that Python is set up in your local environment, and you are comfortable with Jupyter notebooks, let's get equally comfortable with Scikit-learn (pronounce it `sci` as in `science`). Scikit-learn provides an [extensive API](https://scikit-learn.org/stable/modules/classes.html#api-ref) to help you perform ML tasks.
+Berdasarkan [situs mereka](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn" adalah sebuah *open-source library* untuk *machine-learning* yang dapat digunakan untuk *supervised* dan *unsupervised learning*. Scikit-learn juga menyediakan beragam alat untuk *model-fitting*, *data preprocessing*, seleksi dan evaluasi model, dll.
-According to their [website](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection and evaluation, and many other utilities."
+Dalam kursus ini, kamu akan menggunakan Scikit-learn dan beberapa alat lainnya untuk membangun model *machine-learning* untuk mengerjakan apa yang kami panggil tugas '*machine-learning* tradisional'. Kami sengaja menghindari *neural networks* dan *deep learning* sebab mereka akan dibahas dengan lebih lengkap dalam kurikulum 'AI untuk pemula' nanti.
-In this course, you will use Scikit-learn and other tools to build machine learning models to perform what we call 'traditional machine learning' tasks. We have deliberately avoided neural networks and deep learning, as they are better covered in our forthcoming 'AI for Beginners' curriculum.
+Scikit-learn memudahkan pembangunan dan evaluasi model-model. Dia terutama fokus pada menggunakan data numerik dan mempunyai beberapa *dataset* yang siap sedia untuk digunakan sebagai alat belajar. Dia juga mempunyai model yang sudah dibangun untuk murid-murid untuk langsung coba. Mari menjelajahi proses memuat data yang sudah disiapkan dan menggunakan model ML pengestimasian pertama menggunakan Scikit-learn dengan data sederhana.
-Scikit-learn makes it straightforward to build models and evaluate them for use. It is primarily focused on using numeric data and contains several ready-made datasets for use as learning tools. It also includes pre-built models for students to try. Let's explore the process of loading prepackaged data and using a built in estimator first ML model with Scikit-learn with some basic data.
-## Exercise - your first Scikit-learn notebook
+## Latihan - Scikit-learn *notebook* pertamamu
-> This tutorial was inspired by the [linear regression example](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) on Scikit-learn's web site.
+> Tutorial ini terinspirasi [contoh regresi linear ini](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) di situs Scikit-learn.
-In the _notebook.ipynb_ file associated to this lesson, clear out all the cells by pressing the 'trash can' icon.
+Dalam file _notebook.ipynb_ dari pelajaran ini, kosongkan semua sel dengan mengklik tombol berlambang 'tempat sampah'.
-In this section, you will work with a small dataset about diabetes that is built into Scikit-learn for learning purposes. Imagine that you wanted to test a treatment for diabetic patients. Machine Learning models might help you determine which patients would respond better to the treatment, based on combinations of variables. Even a very basic regression model, when visualized, might show information about variables that would help you organize your theoretical clinical trials.
+Dalam bagian ini, kamu akan bekerja dengan sebuah *dataset* kecil tentang diabetes yang datang bersama dengan Scikit-learn yang dimaksud sebagai bahan ajaran. Bayangkan bahwa kamu ingin mencoba sebuah cara pengobatan untuk pasien diabetes. Model *machine learning* mungkin dapat membantu kamu menentukan pasien mana merespon lebih baik pada pengobatan tersebut berdasarkan kombinasi-kombinasi variabel. Bahkan sebuah model regresi yang sederhana, saat divisualisasikan, dapat menunjukkanmu informasi tentang variabel-variabel yang dapat membantu kamu mengorganisasikan uji-uji klinis teoritismu.
-โ
There are many types of regression methods, and which one you pick depends on the answer you're looking for. If you want to predict the probable height for a person of a given age, you'd use linear regression, as you're seeking a **numeric value**. If you're interested in discovering whether a type of cuisine should be considered vegan or not, you're looking for a **category assignment** so you would use logistic regression. You'll learn more about logistic regression later. Think a bit about some questions you can ask of data, and which of these methods would be more appropriate.
+โ
Ada banyak macam metode regresi, dan yang mana yang kamu pilih tergantung pada jawaban yang kamu sedang cari. Kalau kamu ingin memprediksi tinggi badan seseorang dari usianya, kamu bisa menggunakan regresi linear, karena kamu mencari sebuah **nilai numerik**. Kalau kamu tertarik pada apa sebuah jenis kuliner sebaiknya dianggap sebagai vegan atau tidak, kamu sedang mencari sebuah **kategorisasi/klasifikasi**; kamu bisa menggunakan regresi logistik. Kamu akan belajar lebih banyak tentang regresi logistik nanti. Pikirkan dahulu beberapa pertanyaan yang kamu bisa tanyakan dari data yang ada dan metode yang mana akan paling cocok.
-Let's get started on this task.
+Mari mulai mengerjakan tugas ini.
-### Import libraries
+### Impor *library*
-For this task we will import some libraries:
+Untuk tugas ini, kita akan mengimpor beberapa *library*:
-- **matplotlib**. It's a useful [graphing tool](https://matplotlib.org/) and we will use it to create a line plot.
-- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) is a useful library for handling numeric data in Python.
-- **sklearn**. This is the Scikit-learn library.
+- **matplotlib**. Sebuah [alat untuk membuat grafik](https://matplotlib.org/) yang kita akan gunakan untuk membuat sebuah grafik garis.
+- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) adalah sebuah *library* berguna untuk menangani data numerik di Python.
+- **sklearn**. Ini adalah *library* Scikit-learn.
-Import some libraries to help with your tasks.
+Imporlah *library-library* yang akan membantu dengan tugasmu.
-1. Add imports by typing the following code:
+1. Tambahlah impor dengan mengetik kode berikut:
```python
import matplotlib.pyplot as plt
@@ -108,36 +110,35 @@ Import some libraries to help with your tasks.
from sklearn import datasets, linear_model, model_selection
```
- Above you are importing `matplottlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
-
-### The diabetes dataset
+ Di atas, kamu sedang mengimpor `matplottlib`, `numpy`. Selain itu, kamu juga sedang mengimpor `datasets`, `linear_model` dan `model_selection` dari `sklearn`. `model_selection` digunakan untuk memisahkan data menjadi set latihan dan set ujian.
-The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
+### *Dataset* diabetes
-age: age in years
-bmi: body mass index
-bp: average blood pressure
-s1 tc: T-Cells (a type of white blood cells)
+[*Dataset* diabetes](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) mencakupi 442 sampel data mengenai diabetes dengan 10 variabel utama, termasuk:
-โ
This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
+- age: usia dalam tahun
+- bmi: *body mass index*
+- bp: tekanan darah rata-rata
+- s1 tc: Sel T (sejenis cel darah putih)
-Now, load up the X and y data.
+โ
*Dataset* ini juga mempunyai konsep 'jenis kelamin' sebagai sebuah variabel utama yang penting dalam riset diabetes. Banyak *dataset* medis mempunyai klasifikasi binari ini. Pikirkan sejenak bagaimana kategorisasi seperti yang ini dapat mengecualikan bagian tertentu dari sebuah populasi dari pengobatan.
-> ๐ Remember, this is supervised learning, and we need a named 'y' target.
+Sekarang, muatkan data X dan y.
-In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y` will be the regression target.
+> ๐ Ingatlah, ini adalah *supervised learning*, jadi kita perlu sebuah target (dinamakan 'y').
-1. Add some print commands to show the shape of the data matrix and its first element:
+Dalam sebuah sel kode yang baru, muatkan *dataset* diabetes dengan memanggil `load_diabetes()`. Input `return_X_y=True` menunjukkan bahwa `X` adalah sebuah matriks data dan `y` adalah target regresi.
+1. Tambah beberapa instruksi *print* untuk menunjukkan ukuran data matriks dan elemen pertama matriks tersebut.
```python
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
- What you are getting back as a response, is a tuple. What you are doing is to assign the two first values of the tuple to `X` and `y` respectively. Learn more [about tuples](https://wikipedia.org/wiki/Tuple).
+ Respon yang didapati adalah sebuah *tuple*. Kamu sedang menetapkan kedua nilai pertama dalam *tuple* itu ke dalam `X` dan `y` secara berturut. Pelajari lebih banyak [tentant *tuples*](https://wikipedia.org/wiki/Tuple).
- You can see that this data has 442 items shaped in arrays of 10 elements:
+ Kamu bisa melihat bahwa data ini berupa 422 nilai yang disusun menjadi beberapa `array` dengan 10 elemen:
```text
(442, 10)
@@ -145,38 +146,38 @@ In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
- โ
Think a bit about the relationship between the data and the regression target. Linear regression predicts relationships between feature X and target variable y. Can you find the [target](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) for the diabetes dataset in the documentation? What is this dataset demonstrating, given that target?
+ โ
Pikirkan sejenak tentang hubungan antara data dan target regresi. Apa kamu bisa menemukan [targetnya](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) untuk *database* diabetes dalam dokumentasinya? Mengetahui targetnya, apa yang *dataset* ini sedang mendemonstrasikan?
-2. Next, select a portion of this dataset to plot by arranging it into a new array using numpy's `newaxis` function. We are going to use linear regression to generate a line between values in this data, according to a pattern it determines.
+2. Lalu, pilih sebuah porsi dataset ini untuk digambarkan dengan menyusuninya menjadi sebuah `array` baru dengan fungsi `newaxis` dari `numpy`. Kita akan menggunakan regresi linear untuk menggambar sebuah garis antara nilai-nilai dalam data ini sesuai dengan pola yang ditentukannya.
```python
X = X[:, np.newaxis, 2]
```
- โ
At any time, print out the data to check its shape.
+ โ
Kapanpun, *print*-lah datanya untuk memeriksa bentuknya.
-3. Now that you have data ready to be plotted, you can see if a machine can help determine a logical split between the numbers in this dataset. To do this, you need to split both the data (X) and the target (y) into test and training sets. Scikit-learn has a straightforward way to do this; you can split your test data at a given point.
+3. Sekarang datanya sudah siap untuk digambar. Kamu bisa melihat jikalau sebuah mesin dapat menentukan sebuah perpisahan logika dari nomor-nomor *dataset* ini. Untuk melakukan itu, kamu harus memisahkan data (X) dan target (y) menjadi set latihan dan set ujian. Scikit-learn juga memberi cara untuk melakukan itu; kamu bisa memisahkan data ujianmu pada titik tertentu.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
-4. Now you are ready to train your model! Load up the linear regression model and train it with your X and y training sets using `model.fit()`:
+4. Sekarang, kamu sudah siap untuk melatihkan modelmu! Muatkan dahulu data regresi linear dan latihkan modelmu dengan set X dan y-mu dengan `model.fit()`:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
- โ
`model.fit()` is a function you'll see in many ML libraries such as TensorFlow
+ โ
`model.fit()` adalah sebuah fungsi yang akan kamu temukan dalam banyak *library* ML seperti TensorFlow.
-5. Then, create a prediction using test data, using the function `predict()`. This will be used to draw the line between data groups
+5. Lalu, buatlah sebuah prediksi dengan data ujianmu dengan fungsi `predict()`. Ini akan digunakan untuk menggambar sebuah garis antara grup-grup data.
```python
y_pred = model.predict(X_test)
```
-6. Now it's time to show the data in a plot. Matplotlib is a very useful tool for this task. Create a scatterplot of all the X and y test data, and use the prediction to draw a line in the most appropriate place, between the model's data groupings.
+6. Sekarang waktunya untuk menggambar data dalam sebuah grafik. Matplotlib adalah sebuah alat yang sangat berguna untuk melakukan itu. Buatlah sebuah petak sebar dari semua X dan y dari set ujian dan gunakan prediksi yang dihasilkan untuk menggambar sebuah garis di tempat yang paling cocok antara grup-grup data modelnya.
```python
plt.scatter(X_test, y_test, color='black')
@@ -184,24 +185,24 @@ In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The
plt.show()
```
- 
+ 
- โ
Think a bit about what's going on here. A straight line is running through many small dots of data, but what is it doing exactly? Can you see how you should be able to use this line to predict where a new, unseen data point should fit in relationship to the plot's y axis? Try to put into words the practical use of this model.
+ โ
Pikirkan sejenak tentang apa yang sedang terjadi di sini. Sebuah garis lurus membentang tengah-tengah titik-titik kecil data. Tetapi apa yang sedang garis itu lakukan? Apa kamu bisa melihat bagaimana kamu bisa menggunakan garis ini untuk memprediksi di mana sebuah data poin baru yang tidak pernah dilihat sebelumnya kemungkinan besar akan terletak berhubungan dengan sumbu y grafik ini? Coba jelaskan dalam kata-kata kegunaan praktis model ini.
-Congratulations, you built your first linear regression model, created a prediction with it, and displayed it in a plot!
+Selamat, kamu telah membangun model regresi linear pertamamu, membuat sebuah prediksi darinya, dan menunjukkannya dalam sebuah grafik!
---
-## ๐Challenge
+## Tantangan
-Plot a different variable from this dataset. Hint: edit this line: `X = X[:, np.newaxis, 2]`. Given this dataset's target, what are you able to discover about the progression of diabetes as a disease?
-## [Post-lecture quiz](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
+Gambarkan sebuah variabel yang beda dari *dataset* ini. Petunjuk: edit baris ini: `X = X[:, np.newaxis, 2]`. Mengetahui target *dataset* ini, apa yang kamu bisa menemukan tentang kemajuan diabetes sebagai sebuah penyakit?
+## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
-## Review & Self Study
+## Review & Pembelajaran Mandiri
-In this tutorial, you worked with simple linear regression, rather than univariate or multiple linear regression. Read a little about the differences between these methods, or take a look at [this video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
+Dalam tutorial ini, kamu bekerja dengan sebuah model regresi linear yang sederhana daripada regresi linear univariat atau berganda. Bacalah sedikit tentang perbedaan antara metode-metode ini atau tontonlah [video ini](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef).
-Read more about the concept of regression and think about what kinds of questions can be answered by this technique. Take this [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) to deepen your understanding.
+Bacalah lebih banyak tentang konsep regresi dan pikirkanlah tentang jenis pertanyaan apa saja yang bisa dijawab teknik ini. Cobalah [tutorial ini](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) untuk memperdalam pemahamanmu.
-## Assignment
+## Tugas
-[A different dataset](assignment.md)
+[*Dataset* yang beda](assignment.md)
From 21dc2f961b3cd1c2af7ebcb2922b24728db39654 Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Tue, 6 Jul 2021 21:29:47 +0700
Subject: [PATCH 4/8] Add Indonesian translations for 2-Regression/Preface
---
2-Regression/translations/README.id.md | 33 ++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
create mode 100644 2-Regression/translations/README.id.md
diff --git a/2-Regression/translations/README.id.md b/2-Regression/translations/README.id.md
new file mode 100644
index 000000000..a1085fc84
--- /dev/null
+++ b/2-Regression/translations/README.id.md
@@ -0,0 +1,33 @@
+# Model regresi untuk *machine learning*
+## Topik regional: Model regresi untuk harga labu di Amerika Utara ๐
+
+Di Amerika Utara, labu seringkali diukir menjadi muka-muka seram untuk Halloween. Mari mencari tahu lebih banyak tentang sayur menarik ini!
+
+
+> Foto oleh Beth Teutschmann di Unsplash
+
+## Apa yang kamu akan pelajari
+
+Pelajaran-pelajaran dalam seksi ini mencakupi jenis-jenis regresi dalam konteks *machine learning*. Model regresi dapat membantu menentukan _hubungan_ antara variabel-variabel. Model jenis ini dapat memprediksi nilai-nilai seperti panjang, temperatur, atau usia, sehingga mengemukakan hubungan-hubungan antara variabel dengan menganalisis poin-poin data.
+
+Dalam seri pelajaran ini, kamu akan menemukan perbedaan antara regresi linear dan logistik, dan kapan untuk menggunakan satu atau yang lainnya.
+
+Selain itu, kamu akan disiapkan untuk mulai mengerjakan tugas *machine learning*, termasuk mengkonfigurasi Visual Studio Code untuk mengelola *notebook*, lingkungan wajar untuk *data scientist*. Kamu akan menemukan Scikit-learn, sebuah *library* untuk *machine learning*, dan kamu akan membangun model pertamamu dengan memfokus pada model regresi dalam bab ini.
+
+> Ada alat-alat *low-code* yang dapat membantumu belajar tentang bekerja dengan model regresi. Cobalah [Azure ML untuk tugas ini](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-15963-cxa).
+
+### Pelajaran
+
+1. [Alat-alat seorang *data scientist*](1-Tools/README.md)
+2. [Mengelola data](2-Data/README.md)
+3. [Regresi linear dan polinomial](3-Linear/README.md)
+4. [Regresi logistik](4-Logistic/README.md)
+
+---
+### Kredit
+
+"ML with regression" (ML dengan regresi) ditulis dari โฅ๏ธ oleh [Jen Looper](https://twitter.com/jenlooper)
+
+โฅ๏ธ Kontributor kuis termasuk: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) dan [Ornella Altunyan](https://twitter.com/ornelladotcom)
+
+*Dataset* labu disarankan [proyek ini di Kaggle](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) dan datanya disumberkan dari [Specialty Crops Terminal Markets Standard Reports (Laporan Standar Pasar Terminal Tanaman Khusus)](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) yang didistribusikan Departemen Agrikultur Amerika Serikat. Kami telah menambahkan beberapa poin tentang warna berdasarkan jenis labu untuk menormalisasi distribusi data. Data ini terbuka untuk umum (*public domain*).
From 1a1feabfd7847fa0682d08bb88224ba84bb0273d Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Tue, 6 Jul 2021 22:55:20 +0700
Subject: [PATCH 5/8] Add Indonesian translation for 2-Regression/2-Data
---
2-Regression/2-Data/translations/README.id.md | 202 ++++++++++++++++++
1 file changed, 202 insertions(+)
create mode 100644 2-Regression/2-Data/translations/README.id.md
diff --git a/2-Regression/2-Data/translations/README.id.md b/2-Regression/2-Data/translations/README.id.md
new file mode 100644
index 000000000..4e932101d
--- /dev/null
+++ b/2-Regression/2-Data/translations/README.id.md
@@ -0,0 +1,202 @@
+# Membangun sebuah model regresi dengan Scikit-learn: siapkan dan visualisasikan data
+
+> 
+> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/11/)
+
+## Pembukaan
+
+Karena sekarang kamu sudah siap dengan alat-alat yang akan diperlukan untuk mulai melampiaskan pembangunan model *machine learning* dengan Scikit-learn, kamu juga siap untuk mulai membuat pertanyaan dari datamu. Selagi kamu bekerja dengan data dan mengaplikasikan solusi ML, sangatlah penting untuk mengerti bagaimana menanyakan cara yang benar dan tepat untuk mengemukakan potensial *dataset*-mu.
+
+Dalam pelajaran ini, kamu akan belajar:
+
+- Cara mempersiapkan datamu untuk pembangunan model.
+- Cara menggunakan Matplotlib untuk memvisualisasikan data.
+
+## Menanyakan pertanyaan yang tepat dari datamu
+
+Pertanyaan yang perlu dijawab akan menentukan jenis algoritma ML yang kamu akan memanfaatkan. Lalu, kualitas jawaban yang kamu akan dapat sangat tergantung pada sifat datamu (*the nature of your data*).
+
+Lihatlah [data](../data/US-pumpkins.csv) yang disiapkan untuk pelajaran ini. Kamu bisa membuka file .csv ini di VS Code. Membaca dengan cepat, *dataset* ini ada yang kosong dan ada yang campuran data *string* dan data numerik. Adapula sebuah kolom 'Package' yang aneh dan mengandung data antara 'sacks', 'bins', dll. Terus terang, data ini amburadul.
+
+Faktanya adalah tidak sering kita dihadiahkan sebuah *dataset* yang langsung bisa digunakan untuk membuat sebuah model ML. Dalam pelajaran ini, kamu akan belajar bagaimana menyiapkan sebuah *dataset* 'mentah' menggunakan *library* standar Python. Kamu juga akan belajar aneka teknik untuk memvisualisasikan datanya.
+
+## Studi kasus: 'pasar labu'
+
+Dalam folder ini kamu akan menemukan sebuah file .csv dalam folder `data` bernama [US-pumpkins.csv](../data/US-pumpkins.csv) yang mempunyai 1757 baris data tentang pasar labu disortir dalam pengelompokkan berdasarkan kota. Ini adalah data mentah yang diambil dari [Specialty Crops Terminal Markets Standard Reports (Laporan Standar Pasar Terminal Tanaman Khusus)](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) yang didistribusi Departemen Agrikultur Amerika Serikat.
+
+### Menyiapkan data
+
+Data ini terbuka untuk umum (*publik domain*) dan bisa diunduh sebagai banyak file terpisah berdasarkan kota dari situs internet Departemen Agrikultur Amerika Serikat. Supaya tidak berurusan dengan terlalu banyak file, kami telah menggabungkan data dari semua kota menjadi satu *spreadsheet* (file Excel). Jadi kamu sudah _menyiapkan_ datanya sedikit. Selanjutnya, mari kita lihat datanya.
+
+### Data labu - kesimpulan-kesimpulan awal
+
+Apa yang kamu cermati tentang data ini? Kamu sudah melihat bahwa ada campuran *string*, nomor, kekosongan, dan nilai-nilai aneh yang harus diartikan.
+
+Pertanyaan apa yang kamu bisa tanyakan dari data data ini menggunakan teknik regresi? Kalau "Prediksikan harga jual sebuah labu pada bulan tertentu" bagaimana? Melihat datanya sekali lagi, ada beberapa perubahan yang kamu harus terapkan untuk membuat struktur data yang diperlukan untuk tugas ini.
+
+## Latihan - analisiskan data labu
+
+Mari menggunakan [Pandas](https://pandas.pydata.org/) (singkatan dari `Python Data Analysis`), sebuah alat yang sangat beruna untuk membentuk, menganalisis, dan menyiapkan data labu ini.
+
+### Pertama, carilah tanggal yang hilang
+
+Kamu harus mengambil langkah untuk mencari tanggal-tanggal yang hilang terlebih dahulu:
+
+1. Konversi tanggal-tanggalnya menjadi format bulan (tanggal-tanggal ini dalam format Amerika Serikat, yaitu `BULAN/TANGGAL/TAHUN`).
+2. Jadikan data bulan menjadi kolom baru
+
+Buka file _notebook.ipynb_ dalam Visual Studio Code dan impor *spreadsheet*-nya menjadi sebuah *dataframe* Pandas.
+
+1. Gunakan fungsi `head()` untuk melihat lima baris pertama.
+
+ ```python
+ import pandas as pd
+ pumpkins = pd.read_csv('../../data/US-pumpkins.csv')
+ pumpkins.head()
+ ```
+
+ โ
Fungsi apa yang akan kamu gunakan untuk melihat lima baris **terakhir**?
+
+2. Periksa apa ada data yang hilang dalam *dataframe* ini:
+
+ ```python
+ pumpkins.isnull().sum()
+ ```
+
+ Ada data yang hilang, namun mungkin tidak akan diperlukan untuk tugas ini.
+
+3. Untuk menjadikan *dataframe* kamu lebih mudah untuk digunakan, buanglah beberapa kolom menggunakan `drop()` dan simpanlah kolom-kolom yang diperlukan saja:
+
+ ```python
+ new_columns = ['Package', 'Month', 'Low Price', 'High Price', 'Date']
+ pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
+ ```
+
+### Kedua, tentukan harga rata-rata labu
+
+Pikirkan bagaimana caranya menentukan harga rata-rata sebuah labu pada bulan tertentu. Kamu akan pilih kolom apa saja untuk tugas ini? Petunjuk: kamu akan perlu 3 kolom.
+
+Solusi: Ambil rata-rata kolom `Low Price` dan `High Price` untuk mengisi kolom `Price` yang baru. Terus, konversikan kolom `Date` untuk hanya menunjukkan bulan saja. Untungnya, berdasarkan pemeriksaan di atas, tidak ada data tanggal atau harga yang hilang.
+
+1. Untuk mengkalkulasi rata-rata, tambahlah kode berikut:
+
+ ```python
+ price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
+
+ month = pd.DatetimeIndex(pumpkins['Date']).month
+
+ ```
+
+ โ
Jangan ragu untuk mem-*print* data apapun yang kamu ingin periksa menggunakan `print(month)`.
+
+2. Sekarang, salinlah data yang telah dikonversi ke sebuah *dataframe* Pandas yang baru:
+
+ ```python
+ new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
+ ```
+
+ Jika *dataframe* baru ini di-*print*, kamu akan lihat sebuah *dataset* yang rapih darimana kamu bisa membangun model regresi barumu.
+
+### But wait! There's something odd here
+### Tunggu! Ada yang aneh di sini
+
+Kalau kamu lihat kolom `Package`, labu dijual dalam berbagai konfigurasi. Beberapa dijual dalam satuan '1 1/9 bushel', beberapa per labu, beberapa per pon, dan beberapa dalam dus-dus besar dengan kelebaran yang berbeda-beda.
+
+> Kelihatannya susah untuk menimbang labu secara konsisten
+
+Menggali data orisinal lebih dalam, sangatlah menarik untuk melihat apapun dengan `Unit of Sale` (satuan penjualan) yang sama dengan 'EACH' atau 'PER BIN' akan mempunyai jenis `Package` yang per inci, per bin, atau 'each'. Kelihatannya susah untuk menimbang labu secara konsisten, jadi mari memilah datanya dengan hanya memilih labu yang kolom `Package`-nya sama dengan *string* 'bushel'.
+
+1. Tambah sebuah filter di atas file tetapi dibawah impor .csv yang di awal
+
+ ```python
+ pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
+ ```
+
+ Kalau kamu *print* datanya sekarang, kamu bisa lihat bahwa kamu hanya mendapatkan sekitar 415 baris data yang mengandung data labu per bushel.
+
+### Tunggu! Masih ada satu lagi
+
+Apa kamu sadar bahwa jumlah bushel berbeda-beda per baris? Kamu harus menormalisasi harganya supaya kamu menunjukkan harga per bushel. Gunakanlah sedikit matematika untuk menstandarisasinya.
+
+1. Tambahlah beberapa baris ini setelah blok yang membuat *dataframe* new_pumpkins:
+
+ ```python
+ new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
+
+ new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
+ ```
+
+โ
Berdasarkan [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), berat satu bushel tergantung jenis hasil bumi sebab bushel adalah satuan volume. "Satu bushel tomat, sebagai contoh, seharusnya seberat 56 pon (25.4 kg)... Dedaunan mengambil lebih banyak ruang tetapi lebih ringan, jadi satu bushel bayam hanya seberat 20 pon (9.1 kg)" (diterjemah). Lumayan rumit ya! Kita tidak usah mengkonversi bushel ke pon saja bagaimana, jadi kita gunakan satuan harga per bushel? Namun, semua riset ini tentang bushel labu menunjukkan sebagaimana pentingnya untuk mengerti sifat datamu!
+
+Sekarang, kamu bisa meneliti harga per satuan berdasarkan hitungan bushel mereka. Jika kamu *print* datanya sekali lagi, kamu bisa lihat bagaimana telah distandarisasi.
+
+โ
Apa kamu sadar bahwa labu yang dijual per setengah bushel sangat mahal? Kira-kira mengapa ya? Petunjuk: labu kecil jauh lebih mahal daripada labu besar, mungkin karena ada lebih banyak per bushel, apalagi mengingat pula bahwa satu labu besar mempunyai rongga kosong yang besar di dalamnya.
+
+## Strategi Visualisasi
+
+Sebagian dari peran seorang *data scientist* adalah untuk mendemonstrasikan kualitas dan sifat data yang sedang digunakan. Untuk melakukan ini, mereka seringkali membuat visualisasi-visualisasi atau grafik menarik yang menunjukkan aspek-aspek berbeda tentang datanya. Dengan cara ini, mereka dapat menunjukkan hubungan-hubungan dan celah-celah secara visual. Kalau tidak secara visual, akan susah untuk menemukan pola-pola tersebut.
+
+Visualisasi juga bisa membantu menentukan teknik *machine learning* yang palingn cocok untuk datanya. Sebagai contoh, sebuah petak sebar yang kelihatannya mengikuti sebuah garis mengindikasikan bahwa data ini adalah kandidat baik untuk latihan regresi linear.
+
+Satu *library* visualisasi data yang bekerja dengan baik dalam sebuah *Jupyter notebook* adalah [Matplotlib](https://matplotlib.org/) (yang kamu juga lihat dalam pelajaran sebelumnya).
+
+> Carilah pengalaman dalam memvisualisasi data dengan [tutorial-tutorial ini](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-15963-cxa).
+
+## Latihan - sebuah experimen dengan Matplotlib
+
+Coba membuat beberapa grafik sederhana untuk menunjukkan *dataframe* baru yang baru kamu buat. Kira-kira, sebuah plot garis akan menunjukkan apa ya?
+
+1. Impor Matplotlib di atas file tetapi di bawah impor Pandas:
+
+ ```python
+ import matplotlib.pyplot as plt
+ ```
+
+2. Jalankan ulang keseluruhan *notebook*-nya.
+3. Di bagian bawah *notebook*-nya, tambahkan sebuah sel untuk menggambarkan datanya sebagai sebuah kotak.
+
+ ```python
+ price = new_pumpkins.Price
+ month = new_pumpkins.Month
+ plt.scatter(price, month)
+ plt.show()
+ ```
+
+ 
+
+ Apakah grafik ini berguna? Apa ada yang mengejutkanmu?
+
+ Sebenarnya tidak terlalu berguna karena dia hanya menunjukkan datamu sebagai sebuah penyebaran poin pada bulan tertentu.
+
+### Jadikan berguna
+
+Untuk menjadikan sebuah grafik menjadi berguna, biasanya datanya harus dikelompokkan dengan suatu cara. Kita coba membuat suatu plot di mana sumbu y menunjukkan bulan dan datanya mendemonstrasikan distribusi data, yuk!
+
+1. Tambah sebuah sel untuk membuat sebuah diagram batang berkelompok:
+
+ ```python
+ new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
+ plt.ylabel("Pumpkin Price")
+ ```
+
+ 
+
+ Nah, ini lebih berguna! Kelihatannya visualisasi ini mengindikasi bahwa labu itu paling mahal pada bulan September dan Oktober. Apa itu sesuai ekspektasimu? Mengapa?
+
+---
+
+## ๐Tantangan
+
+Jelajahi jenis-jenis visualisasi yang beda dan yang disediakan Matplotlib. Jenis mana yang paling cocok untuk kasus regresi?
+
+## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/12/)
+
+## Review & Pembelajaran Mandiri
+
+Lihatlah beragam cara memvisualisasi data. Buatlah sebuah daftar dari aneka *library* yang tersedia dan catatlah yang mana yang paling baik untuk jenis-jenis tugas tertentu. Sebagai contoh, bagaimana dengan visualisasi 2D vs. 3D? Apa yang kamu temukan?
+
+## Tugas
+
+[Menjelajahi visualisasi](assignment.md)
From ef9b1bb9640dbf9c9fcb788d42e570223441c68c Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Wed, 7 Jul 2021 22:40:35 +0700
Subject: [PATCH 6/8] Fix Indonesian translation of 'datapoint'
---
2-Regression/1-Tools/translations/README.id.md | 4 ++--
2-Regression/translations/README.id.md | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/2-Regression/1-Tools/translations/README.id.md b/2-Regression/1-Tools/translations/README.id.md
index b29301e2a..4345460ab 100644
--- a/2-Regression/1-Tools/translations/README.id.md
+++ b/2-Regression/1-Tools/translations/README.id.md
@@ -185,9 +185,9 @@ Dalam sebuah sel kode yang baru, muatkan *dataset* diabetes dengan memanggil `lo
plt.show()
```
- 
+ 
- โ
Pikirkan sejenak tentang apa yang sedang terjadi di sini. Sebuah garis lurus membentang tengah-tengah titik-titik kecil data. Tetapi apa yang sedang garis itu lakukan? Apa kamu bisa melihat bagaimana kamu bisa menggunakan garis ini untuk memprediksi di mana sebuah data poin baru yang tidak pernah dilihat sebelumnya kemungkinan besar akan terletak berhubungan dengan sumbu y grafik ini? Coba jelaskan dalam kata-kata kegunaan praktis model ini.
+ โ
Pikirkan sejenak tentang apa yang sedang terjadi di sini. Sebuah garis lurus membentang tengah-tengah titik-titik kecil data. Tetapi apa yang sedang garis itu lakukan? Apa kamu bisa melihat bagaimana kamu bisa menggunakan garis ini untuk memprediksi di mana sebuah titik data baru yang tidak pernah dilihat sebelumnya kemungkinan besar akan terletak berhubungan dengan sumbu y grafik ini? Coba jelaskan dalam kata-kata kegunaan praktis model ini.
Selamat, kamu telah membangun model regresi linear pertamamu, membuat sebuah prediksi darinya, dan menunjukkannya dalam sebuah grafik!
diff --git a/2-Regression/translations/README.id.md b/2-Regression/translations/README.id.md
index a1085fc84..6b228c147 100644
--- a/2-Regression/translations/README.id.md
+++ b/2-Regression/translations/README.id.md
@@ -8,7 +8,7 @@ Di Amerika Utara, labu seringkali diukir menjadi muka-muka seram untuk Halloween
## Apa yang kamu akan pelajari
-Pelajaran-pelajaran dalam seksi ini mencakupi jenis-jenis regresi dalam konteks *machine learning*. Model regresi dapat membantu menentukan _hubungan_ antara variabel-variabel. Model jenis ini dapat memprediksi nilai-nilai seperti panjang, temperatur, atau usia, sehingga mengemukakan hubungan-hubungan antara variabel dengan menganalisis poin-poin data.
+Pelajaran-pelajaran dalam seksi ini mencakupi jenis-jenis regresi dalam konteks *machine learning*. Model regresi dapat membantu menentukan _hubungan_ antara variabel-variabel. Model jenis ini dapat memprediksi nilai-nilai seperti panjang, temperatur, atau usia, sehingga mengemukakan hubungan-hubungan antara variabel dengan menganalisis titik-titik data.
Dalam seri pelajaran ini, kamu akan menemukan perbedaan antara regresi linear dan logistik, dan kapan untuk menggunakan satu atau yang lainnya.
From effb55697cdb39fd04df3ae57f97762ed3d7e087 Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Wed, 7 Jul 2021 23:53:47 +0700
Subject: [PATCH 7/8] Add Indonesian translation for 2-Regression/3-Linear
---
.../3-Linear/translations/README.id.md | 335 ++++++++++++++++++
1 file changed, 335 insertions(+)
create mode 100644 2-Regression/3-Linear/translations/README.id.md
diff --git a/2-Regression/3-Linear/translations/README.id.md b/2-Regression/3-Linear/translations/README.id.md
new file mode 100644
index 000000000..548d2030a
--- /dev/null
+++ b/2-Regression/3-Linear/translations/README.id.md
@@ -0,0 +1,335 @@
+# Bangun sebuah model regresi dengan Scikit-learn: regresi dua arah
+
+
+> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
+## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/13/)
+### Pembukaan
+
+Selama ini kamu telah menjelajahi apa regresi itu dengan data contoh yang dikumpulkan dari *dataset* harga labu yang kita akan gunakan terus sepanjang pelajaran ini. Kamu juga telah memvisualisasikannya dengan Matplotlib.
+
+Sekarang kamu sudah siap terjun ke dalam regresi untuk ML. Dalam pelajaran ini, kamu akan belajar lebih tentang dua jenis regresi: _regresi linear sederhana_ dan _regresi polinomial_ serta sedikit matematika yang mendasari kedua teknik ini.
+
+> Sepanjang kurikulum ini, kami mengasumsi kamu punya pengetahuan matematika yang minim dan ingin tetap membuat pelajaran ini terjangkau bagi murid-murid dari bidang-bidang lain. Jadi perhatikan catatan, ๐งฎ info, diagram, dan alat-alat belajar lainnya untuk membantu pemahaman.
+
+### Prasyarat
+
+Kamu harusnya sudah terbiasa sekarang dengan struktur data labu yang kita sedang teliti. Datanya harusnya sudah dimuat dan dibersihkan dalam file _notebook.ipynb_ pelajaran ini. Dalam file ini, harga labu ditampilkan per bushel dalam *dataframe* yang bari. Pastikan kamu bisa menjalankan *notebook-notebook* ini di *kernels* di Visual Studio Code.
+
+### Persiapan
+
+Ingat, kamu sedang memuat data ini untuk menanyakan pertanyaan darinya.
+
+- Kapankah waktu terbaik untuk membeli labu?
+- Saya kira-kira harus bayar berapa untuk satu kotak labu mini?
+- Apa saya sebaiknya membelinya dalam keranjang-keranjang setengah bushel atau kardus-kardus 1 1/9 bushel?
+Ayo terjun lebih lagi ke dalam data ini.
+
+Dalam pelajaran sebelumnya, kamu membuat sebuah *dataframe* Pandas, mengisinya dengan sebagian *dataset* orisinal, dan menstandarisasi harganya per bushel. Tetapi, dengan begitu, kamu hanya dapat mengumpul sekitar 400 titik data dan itupun hanya untuk bulan-bulan musim gugur.
+
+Lihatlah data yang kita sudah muat dalam *notebook* yang terlampir pelajaran ini. Data telah di muat dan sebuah petak sebar inisial telah digambar untuk menunjukkan data per bulan. Mungkin kita bisa dapat lebih banyak detail tentang sifat datanya dengan membersih-bersihkannya lebih lagi.
+
+## Sebuah garis regresi linear
+
+Seperti yang kamu telah belajar dalam Pelajaran 1, tujuan sebuah latihan regresi linear adalah untuk dapat menggambar sebuah garis untuk:
+
+- **Menunjukkan hubungan antar-variabel**. Menunjukkan hubungan antara variabel-variabel.
+- **Membuat prediksi**. Membuat prediksi akurat tentang di mana sebuah titik data baru akan terletak berhubungan dengan garis tersebut.
+
+Dalam kasus **Regresi Kuadrat Terkecil (_Least-Squares Regression_)**, biasanya garis seperti ini digambar. Istilah 'kuadrat terkecil' berarti semua titik data yang mengitari garis regresi dikuadratkan dan dijumlahkan. Secara ideal, harusnya jumlah akhirnya sekecil mungkin, karena kita ingin kesalahan (error) terkecil, alias `kuadrat terkecil`.
+
+Kita melakukan itu sebab kita ingin memodelkan sebuah garis yang jarak kumulatifnya dari semua titik data itu sekecil mungkin. Kita juga mengkuadratkan setiap suku sebelum dijumlahkan karena kita fokus pada besarannya daripada arahnya.
+
+> **๐งฎ Tunjukkan matematikanya kepadaku**
+>
+> Garis ini, dipanggil _garis yang paling cocok_, dapat diekspresikan dalam [sebuah persamaan](https://en.wikipedia.org/wiki/Simple_linear_regression):
+>
+> ```
+> Y = a + bX
+> ```
+>
+> `X` adalah 'variabel penerang'. `Y` adalah 'variabel dependen'. Gradien garisnya adalah `b`, dan `a` adalah titik potong sumbu y yaitu nilai `Y` saat `X = 0`.
+>
+>
+>
+> Pertama, hitunglah gradien `b`. Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
+>
+> Dalam kata lain, dan berhubungan pula dengan pertanyaan awal data labu kita "prediksikan harga satu bushel labu setiap bulan", `X` merujuk pada harganya, sedangkan `Y` akan merujuk pada bulan penjualan.
+>
+>
+>
+> Hitunglah nilai Y. Kalau harganya $4, artinya pasti April! Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
+>
+> Matematika yang mengkalkulasi garis ini harus mendemonstrasikan gradien garisnya yang juga tergantung pada titik potongnya pada sumbu y, alias apa `Y`-nya saat `X = 0`.
+>
+> Kamu bisa melihat metode menghitung nilai-nilai ini di situs internet [*Math is Fun* (Matematika Itu Menyenangkan)](https://www.mathsisfun.com/data/least-squares-regression.html). Kunjungi [kalkulator kuadrat terkecil ini](https://www.mathsisfun.com/data/least-squares-calculator.html) juga untuk melihat bagaimana nomor-nomor ini mengubah garisnya.
+
+## Korelasi
+
+Satu lagi yang harus dipahami adalah **Koefisien Korelasi** antara variabel X dan Y yang tersedia. Menggunakan sebuah petak sebar, kamu bisa memvisualisasi korelasi ini dengan cepat. Sebuah grafik dengan titik-titik data yang tersebar rapi seperti sebuah garis mempunyai korelasi yang tinggi. Namun, sebuah grafik dengan titik-titik data yang tersebar di mana-mana antara X dan Y mempunyai korelasi yang rendah.
+
+Sebuah model regresi linear yang bagus akan mempunyai Koefisien Korelasi yang tinggi (lebih dekat ke 1 daripada ke 0) menggunakan metode Regresi Kuadrat Terkecil dengan sebuah garis regresi.
+
+โ
Jalankan *notebook* yang terlampir dalam pelajaran ini dan lihatlah petak sebar City (Kota) ke Price (Harga). Apa data yang menghubungkan City ke Price untuk penjualan labu mempunyai korelasi yang tinggi atau rendah kelihatannya?
+
+
+## Siapkan datamu untuk regresi
+
+Sekarang dengan pemahamanmu mengenai matematika di balik latihan ini, buatlah sebuah model regresi untuk melihat apa kamu bisa memprediksi paket labu yang mana yang harganya paling baik. Seorang pembeli labu akan ingin mengetahui informasi ini untuk mengoptimasi pembelian labu mereka.
+
+Karena kamu akan menggunakan Scikit-learn, tidak usah mengerjakan ini dengan tangan (walaupun bisa sih!). Dalam blok memrosesan data utama *notebook*-mu untuk pelajaran ini, tambahlah sebuah *library* dari Scikit-learn untuk mengkonversi semua data *string* menjadi nomor secara otomatis:
+
+```python
+from sklearn.preprocessing import LabelEncoder
+
+new_pumpkins.iloc[:, 0:-1] = new_pumpkins.iloc[:, 0:-1].apply(LabelEncoder().fit_transform)
+new_pumpkins.iloc[:, 0:-1] = new_pumpkins.iloc[:, 0:-1].apply(LabelEncoder().fit_transform)
+```
+
+Kalau kamu sekarang simak *dataframe* new_punkins, kamu akan lihat bahwa semua *string* sudah dijadikan nomor. Ini lebih susah untuk kita baca, tetapi jauh lebih mudah untuk Scikit-learn!
+Sekarang kamu bisa membuat lebih banyak keputusan berakal (tidak hanya tebak-tebak dari petak sebarnya) tentang data yang paling cocok untuk regresi.
+
+Coba cari sebuah korelasi bagus antara dua titik data yang berpotensi untuk membangun sebuah model prediksi yang baik. Ternyata, hanya ada korelasi yang lemah antara City dan Price:
+
+```python
+print(new_pumpkins['City'].corr(new_pumpkins['Price']))
+0.32363971816089226
+```
+
+Meskipun begitu, ada korelasi yang sedikit lebih baik antara Package (Paket) dan Price (Harga). Masuk akal juga kan? Biasanya, lebih besar kardusnya, lebih mahal harganya.
+
+```python
+print(new_pumpkins['Package'].corr(new_pumpkins['Price']))
+0.6061712937226021
+```
+
+Sebuah pertanyaan bagus untuk ditanyakan dari data ini adalah "Kira-kira harga sebuah paket labu berapa?"
+
+Mari membangun sebuah model regresi
+
+## Membangun sebuah model linear
+
+Sebelum membangun modelmu, rapikanlah datamu sekali lagi. Buanglah sebuah data nil (null) dan periksalah sekali lagi datanya kelihatannya seperti apa.
+
+```python
+new_pumpkins.dropna(inplace=True)
+new_pumpkins.info()
+```
+
+Lalu, buatlah sebuah *dataframe* baru dari set minimal ini dan *print*:
+
+```python
+new_columns = ['Package', 'Price']
+lin_pumpkins = new_pumpkins.drop([c for c in new_pumpkins.columns if c not in new_columns], axis='columns')
+
+lin_pumpkins
+```
+
+```output
+ Package Price
+70 0 13.636364
+71 0 16.363636
+72 0 16.363636
+73 0 15.454545
+74 0 13.636364
+... ... ...
+1738 2 30.000000
+1739 2 28.750000
+1740 2 25.750000
+1741 2 24.000000
+1742 2 24.000000
+415 rows ร 2 columns
+```
+
+1. Sekarang kamu bisa menetapkan data koordinat X dan y-mu:
+
+ ```python
+ X = lin_pumpkins.values[:, :1]
+ y = lin_pumpkins.values[:, 1:2]
+ ```
+โ
Apa yang sedang terjadi di sini? Kamu sedang menggunakan [notasi perpotongan Python (*Python slice notation*)](https://stackoverflow.com/questions/509211/understanding-slice-notation/509295#509295) untuk membuat dua *array* untuk mengisi `X` dan `y`.
+
+1. Selanjutnya, mulailah rutin pembangunan model:
+
+ ```python
+ from sklearn.linear_model import LinearRegression
+ from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
+ from sklearn.model_selection import train_test_split
+
+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+ lin_reg = LinearRegression()
+ lin_reg.fit(X_train,y_train)
+
+ pred = lin_reg.predict(X_test)
+
+ accuracy_score = lin_reg.score(X_train,y_train)
+ print('Model Accuracy: ', accuracy_score)
+ ```
+
+ Karena korelasinya tidak begitu baik, model yang didapatkan tidak terlalu akurat.
+
+ ```output
+ Model Accuracy: 0.3315342327998987
+ ```
+
+2. Kamu bisa memvisualisasi garis yang digambarkan dalam proses ini:
+
+ ```python
+ plt.scatter(X_test, y_test, color='black')
+ plt.plot(X_test, pred, color='blue', linewidth=3)
+
+ plt.xlabel('Package')
+ plt.ylabel('Price')
+
+ plt.show()
+ ```
+ 
+
+3. Ujilah modelnya dengan sebuah jenis labu hipotetis:
+
+ ```python
+ lin_reg.predict( np.array([ [2.75] ]) )
+ ```
+
+ Harga yang dihasilkan untuk jenis labu mitologis ini adalah:
+
+ ```output
+ array([[33.15655975]])
+ ```
+
+Nomor itu masuk akal jikalau logika garis regresinya benar.
+
+๐ Selamat, kamu baru saja membuat sebuah model yang bisa membantu memprediksi harga beberapa jenis labu. Namun, kamu masih bisa membuatnya lebih baik!
+
+## Regresi polinomial
+
+Jenis lain regresi linear adalah regresi polinomial. Walaupun kadangkali ada hubungan linear antara variabel-variabel โ lebih besar volume labunya, lebih tinggi harganya โ kadangkali hubungan-hubungan ini tidak bisa digambarkan sebagai sebuah bidang atau garis lurus.
+
+โ
Ini ada [beberapa contoh data lain](https://online.stat.psu.edu/stat501/lesson/9/9.8) yang bisa menggunakan regresi polinomial
+
+Tengok kembali hubungan antara Variety (Jenis) dan Price (Harga) dalam grafik sebelumnya. Apa petak sebar ini terlihat seperti harus dianalisis dengan sebuah garis lurus? Mungkin tidak. Kali ini, kamu bisa mencoba regresi polinomial.
+
+โ
Polinomial adalah sebuah pernyataan matematika yang mempunyai satu atau lebih variabel dan koefisien disusun menjadi suku-suku.
+
+Regresi polinomial menghasilkan sebuah garis lengkung supaya lebih cocok dengan data non-linear.
+
+1. Mari kita membuat sebuah *dataframe* yang diisi sebuah segmen dari data orisinal labu:
+
+ ```python
+ new_columns = ['Variety', 'Package', 'City', 'Month', 'Price']
+ poly_pumpkins = new_pumpkins.drop([c for c in new_pumpkins.columns if c not in new_columns], axis='columns')
+
+ poly_pumpkins
+ ```
+
+Sebuah cara bagus untuk memvisualisasi korelasi-korelasi antara data dalam *dataframe-dataframe* adalah untuk menampilkannya dalam sebuah peta '*coolwarm*' (panas-dingin):
+
+2. Gunakan fungsi `Background_gradient()` dengan `coolwarm` sebagai argumennya:
+
+ ```python
+ corr = poly_pumpkins.corr()
+ corr.style.background_gradient(cmap='coolwarm')
+ ```
+ This code creates a heatmap:
+ Kode ini membuat sebuah peta panas
+ 
+
+Melihat peta ini, kamu bisa memvisualisasikan korelasi yang baik antara Package dan Price. Jadi kamu seharusnya bisa membuat sebuah model yang lebih baik daripada yang sebelumnya.
+
+### Buatlah sebuah *pipeline*
+
+Scikit-learn mempunyai sebuah API yang berguna untuk membangun model regresi polinomial โ [API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) `make_pipeline`. Sebuah '*pipeline*' adalah sebuah rantai penaksir. Dalam kasus ini, *pipeline* ini mempunyai fitur-fitur polinomial, atau prediksi-prediksi yang membuat garis non-linear.
+
+1. Bangunlah kolom X dan y:
+
+ ```python
+ X=poly_pumpkins.iloc[:,3:4].values
+ y=poly_pumpkins.iloc[:,4:5].values
+ ```
+
+2. Buatlah *pipeline*-nya dengan fungsi `make_pipeline()`:
+
+ ```python
+ from sklearn.preprocessing import PolynomialFeatures
+ from sklearn.pipeline import make_pipeline
+
+ pipeline = make_pipeline(PolynomialFeatures(4), LinearRegression())
+
+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+ pipeline.fit(np.array(X_train), y_train)
+
+ y_pred=pipeline.predict(X_test)
+ ```
+
+### Buatlah sebuah barisan
+
+Di sini, kamu harus membuat sebuah *dataframe* baru dengan data yang _berurutan_ supaya *pipeline*-nya bisa membuat sebuah barisan.
+
+Tambahlah kode ini:
+
+ ```python
+ df = pd.DataFrame({'x': X_test[:,0], 'y': y_pred[:,0]})
+ df.sort_values(by='x',inplace = True)
+ points = pd.DataFrame(df).to_numpy()
+
+ plt.plot(points[:, 0], points[:, 1],color="blue", linewidth=3)
+ plt.xlabel('Package')
+ plt.ylabel('Price')
+ plt.scatter(X,y, color="black")
+ plt.show()
+ ```
+
+Kamu membuat sebuah *dataframe* baru dengan fungsi `pd.DataFrame`. Lalu kamu mengurutkan isinya dengan fungsi `sort_values()`. Akhirnya kamu membuat sebuah bagan polinomial:
+
+
+
+Kamu bisa melihat garis lengkungnya yang lebih cocok terhadap datamu.
+
+Ayo periksa akurasi modelnya:
+
+ ```python
+ accuracy_score = pipeline.score(X_train,y_train)
+ print('Model Accuracy: ', accuracy_score)
+ ```
+
+ Nah!
+
+ ```output
+ Model Accuracy: 0.8537946517073784
+ ```
+
+Itu bagus! Coba memprediksi harga:
+
+### Buatlah sebuah prediksi
+
+Apa kita bisa memberi input dan dapat sebuah prediksi?
+
+Pakai fungsi `predict()` untuk membuat prediksi:
+
+ ```python
+ pipeline.predict( np.array([ [2.75] ]) )
+ ```
+ Kamu diberi prediksi ini:
+
+ ```output
+ array([[46.34509342]])
+ ```
+
+Itu sangat masuk akal dengan bagan sebelumnya! Selain itu, jika ini model lebih baik daripada yang sebelumnya dengan data ini, kamu bisa siap untuk labu-labu yang lebih mahal ini!
+
+๐ Mantap sekali! Kamu membuat dua model regresi dalam satu pelajaran. Dalam bagian terakhir mengenai regresi, kamu akan belajar tentang regresi logistik untuk pengkategorisasian.
+
+---
+## ๐ Tantangan
+
+Coba-cobalah variabel-variabel yang lain di *notebook* ini untuk melihat bagaimana korelasi berhubungan dengan akurasi model.
+
+## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/14/)
+
+## Review & Pembelajaran Mandiri
+
+Dalam pelajaran ini kita belajar tentang regresi linear. Ada banyak jenis regresi lain yang penting pula. Bacalah tentang teknik *Stepwise*, *Ridge*, *Lasso*, dan *Elasticnet*. [Kursus Pembelajaran Statistik Stanford](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) juga baik untuk belajar lebih lanjut.
+
+## Tugas
+
+[Buatlah sebuah model](assignment.md)
\ No newline at end of file
From 057023145efcff067a47b9591068a2877bf50008 Mon Sep 17 00:00:00 2001
From: iBlueDust <35223375+iBlueDust@users.noreply.github.com>
Date: Fri, 9 Jul 2021 12:52:54 +0700
Subject: [PATCH 8/8] Add Indonesian translation for 2-Regression/4-Logistic
---
.../4-Logistic/translations/README.id.md | 301 ++++++++++++++++++
1 file changed, 301 insertions(+)
create mode 100644 2-Regression/4-Logistic/translations/README.id.md
diff --git a/2-Regression/4-Logistic/translations/README.id.md b/2-Regression/4-Logistic/translations/README.id.md
new file mode 100644
index 000000000..6158e6d97
--- /dev/null
+++ b/2-Regression/4-Logistic/translations/README.id.md
@@ -0,0 +1,301 @@
+# Regresi logistik untuk memprediksi kategori-kategori
+
+
+> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
+## [Kuis pra-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/15/)
+
+## Pembukaan
+
+Dalam pelajaran regresi terakhir, salah satu teknik ML _klasik_ dan sederhana adalah regresi logistik. Teknik ini digunakan untuk mengemukakan pola-pola untuk memprediksi kategori binari. Apa ini sebuah permen coklat atau tidak? Apa penyakit ini menular tidak? Apa pelanggan ini akan memilih produk ini tidak?
+
+Dalam pelajaran ini, kamu akan belajar:
+
+- Sebuah *library* baru untuk pemvisualisasian data
+- Teknik-teknik untuk regresi logistik
+
+โ
Perdalamkan pemahamanmu dalam bekerja dengan regresi jenis ini dalam [modul pembelajaran ini](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-15963-cxa)
+## Prasyarat
+
+Setelah bekerja dengan data labu, kita sekarang sudah terbiasa dengannya untuk menyadari bahwa adapula sebuah kategori binari yang kita dapat menggunakan: `Color` (warna).
+
+Mari membangun sebuah model regresi logistik untuk memprediksi _kemungkinannya labu ini warnanya apa_ berdasarkan beberapa variabel (oranye ๐ atau putih ๐ป).
+
+> Mengapa kita berbicara tentang klasifikasi binary dalam seri pelajaran tentang regresi? Hanya untuk kemudahan linguistik, regresi logistik juga [sebenarnya sebuah metode klasifikasi](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), namun satu yang berdasarkan garis linear. Pelajari lebih lanjut tentang cara-cara lain untuk mengklasifikasi data dalam seri pelajaran berikutnya.
+
+## Tentukan pertanyaannya
+
+Untuk keperluan kita, kita akan mengekspresikannya sebagai pilihan binari 'Orange' atau 'Not Orange' (oranye atau bukan oranye). Adapula kategori 'striped' (belang-belang) dalam dataset kita, tetapi tidak banyak titik datanya, jadi kita tidak akan menggunakannya. Lagipula, kategori itu hilang begitu kita buang nilai-nilai nil (null) dari datasetnya.
+
+> ๐ Tahukah tidak? Kita kadangkali memanggil labu putih labu 'hantu'. Mereka tidak mudah diukir, jadi mereka tidak sepopuler yang oranye pada Halloween. Tetapi mereka keren juga ya!
+
+## Tentang regresi logistik
+
+Regresi logistik berbeda dari regresi linear, jenis regresi yang kamu pelajari sebelumnya, dalam beberapa askpek penting.
+
+### Klasifikasi binari
+
+Regresi logistik tidak mempunyai beberapa fitur regresi linear. Regresi logistik menyediakan sebuah prediksi tentang sebuah kategori binari (seperti "oranye atau bukan oranye"), sedangkan yang lainnya dapat memprediksi nilai-nilai kontinu. Contohnya, dengan mengetahui dari mana labu ini dan kapan dipanennya, regresi linear dapat memprediksi _berapa harganya akan naik_, namun regresi logistik tidak bisa.
+
+
+> Infografik oleh [Dasani Madipalli](https://twitter.com/dasani_decoded)
+### Klasifikasi lain
+
+Ditambah itu, ada banyak jenis regresi logistik, termasuk jenis multinomial dan ordinal:
+
+- **Multinomial** memperlibatkan lebih dari satu kategori - "Oranye, Putih, dan Belang-belang".
+- **Ordinal** memperlibatkan kategori-kategori berurut. Biasanya berguna jika kita inging mengurutkan hasil kita secara logikal, seperti labu-useful if we wanted to order our outcomes logically, like our pumpkins that are ordered by a finite number of sizes (mini,sm,med,lg,xl,xxl).
+
+
+> Infographic by [Dasani Madipalli](https://twitter.com/dasani_decoded)
+
+### Eh, masih linear ya?
+
+Walaupun jenis regresi ini semuanya tentang 'prediksi kategori', jenis ini masih paling efektif jika ada hubungan linear antara variabel dependen (warna) dan independen (sisa *dataset*-nya, seperti kota dan ukuran). Jadi baik juga untuk mencari tahu dahulu apa ada hubungan linear antara variabel-variabel ini.
+
+### Variabel-variabel TIDAK HARUS berkorelasi
+
+Ingat bagaimana regresi linear bekerja lebih baik dengan variabel berkorelasi? Regresi logistik itu kebalikannya: variabel-variabelnya tidak harus berjejer menjadi garis. Artinya, regresi ini bekerja untuk data ini yang korelasinya lumayan lemah.
+
+### Perlu banyak data rapi
+
+Regresi logistik akan memberi hasil lebih akurat jika kamu menggunakan data lebih banyak; *dataset* kecil kita tidak optimal untuk tugas ini, ingatlah itu.
+
+โ
Pikirkan tentang jenis-jenis data yang akan bekerja baik dengan regresi logistik
+
+## Latihan - rapikan data
+
+Pertama, rapikanlah datanya sedikit. Buanglah nilai-nilai nil (null) dan pilihlah beberapa kolom:
+
+1. Tambahlah kode di bawah ini:
+
+ ```python
+ from sklearn.preprocessing import LabelEncoder
+
+ new_columns = ['Color','Origin','Item Size','Variety','City Name','Package']
+
+ new_pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
+
+ new_pumpkins.dropna(inplace=True)
+
+ new_pumpkins = new_pumpkins.apply(LabelEncoder().fit_transform)
+ ```
+
+ Kamu selalu bisa mengintip kedalam *dataframe*-mu:
+
+ ```python
+ new_pumpkins.info
+ ```
+
+### Visualisasi - *grid* berdampingan (*side-by-side grid*)
+
+Sekarang kamu sudah memuat [*notebook* starter](./notebook.ipynb) dengan data labunya sekali lagi dan merapikannya untuk mempertahankan sebuah *dataset* dengan beberapa variabel, termasuk `Color`. Mari memvisualisasi *dataframe*-nya dengan *library* yang beda: [Seaborn](https://seaborn.pydata.org/index.html) yang dibangun di atas Matplotlib yang kita gunakan sebelumnya.
+
+Seaborn menyediakan beberapa cara keren untuk memvisualisasi datamu. Contohnya, kamu bisa membandungkan distribusi datanya untuk setiap titik data dalam sebuah *grid* berdampingan.
+
+1. Buatlah sebuah *grid* dengan meng-*instantiate* sebuah `PairGrid` menggunakan data labu kita `new_pumpkins` diikuti memanggil fungsi `map()`:
+
+ ```python
+ import seaborn as sns
+
+ g = sns.PairGrid(new_pumpkins)
+ g.map(sns.scatterplot)
+ ```
+
+ 
+
+ Dengan mengobservasi datanya secara berdampingan, kamu bisa lihat bagaimana data warnanya berhubungan dengan kolom-kolom lainnya.
+
+ โ
Dengan petak sebar ini, pendalaman menarik apa saja yang kamu bisa membayangkan?
+
+### Gunakan sebuah bagan kawanan (*swarm plot*)
+
+Karena warna adalah sebuah kategori binari (oranye atau bukan oranye), warna disebut 'data kategorikal' dan memerlukan 'sebuah [pendekatan khusus](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) untuk memvisualisasi'. Ada beberapa cara lain untuk memvisualisasi hubungan antara kategori ini dengan variabel-variabel lainnya.
+
+Kamu bisa memvisualisasikan variabel-variabel secara berdampingan dengan bagan-bagan Seaborn.
+
+1. Cobalah sebuah bagan kawanan untuk menunjukkan distribusi nilai:
+
+ ```python
+ sns.swarmplot(x="Color", y="Item Size", data=new_pumpkins)
+ ```
+
+ 
+
+### Bagan biola
+
+Sebuah bagan 'biola' itu berguna sebab kamu bisa memvisualisasi bagaimana data dalam kedua kategori itu terdistribusi dengan mudah. Bagan viola tidak efektif dengan *dataset* yang lebih kecil sebab distribusinya ditampilkan sebagai lebih 'mulus'.
+
+1. Gunakan fungsi `catplot()` dengan parameter `x=Color` dan `kind="violin"`:
+
+ ```python
+ sns.catplot(x="Color", y="Item Size",
+ kind="violin", data=new_pumpkins)
+ ```
+
+ 
+
+ โ
Cobalah membuat bagan ini dan jenis-jenis bagan Seaborn lainnya dengan variabel-variabel lainnya.
+
+Sekarang kita sudah dapat bayangan hubungan antara kedua kategori binary warna dan ukuran. Ayo menjelajahi regresi logistik untuk memprediksi warna sebuah labu tertentu.
+
+> **๐งฎ Perlihatkanlah Matematikanya Kepada Saya**
+>
+> Ingat bagaiaman regresi linear seringkali menggunakan metode kuadrat terkecil untuk tiba pada sebuah nilai? Regresi logistik tergantung pada konsep 'kemungkinan terbesar' menggunakan [fungsi sigmoid](https://wikipedia.org/wiki/Sigmoid_function). Sebuah 'fungsi Sigmoid' terlihat seperti huruf 'S' dalam sistem koordinat Kartesius. Fungsi ini mengambil sebuah nilai dan 'mencorongkannya' menjadi sebuah nomor antara 0 dan 1. Kurva ini juga dipanggil sebuah 'kurva logistik'. Formulanya seperti ini:
+>
+> 
+>
+> Titik tengah sigmoidnya terletak di sumbu X. L adalah nilai maksimum kurvanya. k adalah terjalnya kurvanya. Jika hasil fungsinya lebih dari 0.5, nilai yang diberikan kepada fungsi tersebut akan diklasifikasikan sebagai '1'. Kalau tidak, nilai itu akan diklasifikasikan sebagai '0'.
+
+## Bangunlah modelmu
+
+Scikit-learn membuat membangun model klasifikasi binary sangat mudah.
+
+1. Pilihlah variabel-variabel yang kamu ingin gunakan dalam model klasifikasimu dan bagilah datanya menjadi set latihan dan set ujian dengan fungsi `train_test_split()`:
+
+ ```python
+ from sklearn.model_selection import train_test_split
+
+ Selected_features = ['Origin','Item Size','Variety','City Name','Package']
+
+ X = new_pumpkins[Selected_features]
+ y = new_pumpkins['Color']
+
+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+ ```
+
+2. Sekarang kamu bisa melatihkan modelmu dengan fungsi `fit()` dengan data latihanmu. *Print* hasilnya:
+
+ ```python
+ from sklearn.model_selection import train_test_split
+ from sklearn.metrics import accuracy_score, classification_report
+ from sklearn.linear_model import LogisticRegression
+
+ model = LogisticRegression()
+ model.fit(X_train, y_train)
+ predictions = model.predict(X_test)
+
+ print(classification_report(y_test, predictions))
+ print('Predicted labels: ', predictions)
+ print('Accuracy: ', accuracy_score(y_test, predictions))
+ ```
+
+ Lihatlah *scoreboard* modelmu. Tidak buruk, apalagi hanya dengan 1000 baris data:
+
+ ```output
+ precision recall f1-score support
+
+ 0 0.85 0.95 0.90 166
+ 1 0.38 0.15 0.22 33
+
+ accuracy 0.82 199
+ macro avg 0.62 0.55 0.56 199
+ weighted avg 0.77 0.82 0.78 199
+
+ Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
+ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
+ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
+ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ 0 0 0 1 0 1 0 0 1 0 0 0 1 0]
+ ```
+
+## Pemahaman lebih baik via sebuah 'matriks kebingungan'
+
+Walaupun kamu bisa membuat sebuah *scoreboard* melaporkan [istilah-istilah](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) dengan mem-*print* yang di atas, kamu mungkin bisa memahami modelmu dengan lebih mudah dengan sebuah [matriks kebingungan](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) untuk membantu kita lebih paham akan performa modelnya.
+
+> ๐ Sebuah '[matriks kebingungan](https://wikipedia.org/wiki/Confusion_matrix)' (atau 'matriks kesalahan') adalah sebuah tabel yang mengekspresikan positif benar vs. positif palsu modelmu sehingga mengukur akurasi prediksi=prediksinya.
+
+1. Untuk menggunakan sebuah matriks kebingungan, gunakan fungsi `confusin_matrix()`:
+
+ ```python
+ from sklearn.metrics import confusion_matrix
+ confusion_matrix(y_test, predictions)
+ ```
+
+ Lihatlah matriks kebingungan modelmu:
+
+ ```output
+ array([[162, 4],
+ [ 33, 0]])
+ ```
+
+Apa yang sedang terjadi di sini? Mari kita asumsi dulu bahwa model kita ditanyakan untuk mengklasifikasi antara dua kategori binari: 'labu' dan 'bukan labu'.
+
+- Kalau modelmu memprediksi sesuatu sebagai sebuah labu dan memang benar sesuatu itu adalah sebuah labu, itu disebut positif benar yang diindikasi angka di pojok kiri atas.
+- Kalau modelmu memprediksi sesuatu sebagai bukan sebuah labu tetapi sesuatu itu sebenarnya sebuah labu, itu disebut positif palsu yang diindikasi angka di pojok kanan atas.
+- Kalau modelmu memprediksi sesuati sebagai sebuah labu tetapi sebenarnya bukan sebuah labu, itu disebut negatif palsu yang diindikasi angka di pojok kiri bawah.
+- Kalau modelmu memprediksi sesuati sebagai bukan sebuah labu dan memang benar sesuatu itu bukan sebuah labu, itu disebut negatif benar yang diindikasi angka di pojok kanan bawah.
+
+
+
+> Infografik oleh [Jen Looper](https://twitter.com/jenlooper)
+
+Sebagaimana kamu mungkin sudah pikirkan, lebih baik dapat banyak positif benar dan negatif benar dan sedikit positif palsu dan negatif palsu. Implikasinya adalah performa modelnya bagus.
+
+โ
Pertanyaan: Berdasarkan matriks kebingungan, modelnya baik tidak? Jawaban: Tidak buruk; ada banyak positif benar dan sedikit negatif palsu.
+
+Mari kita lihat kembali istilah-istilah yang kita lihat tadi dengan bantuan matriks kebingungan:
+
+> PB: Positif benar
+> PP: Positif palsu
+> NB: Negatif benar
+> NP: Negatif palsu
+
+๐ Presisi: PB/(PB + NP) Rasio titik data relevan antara semua titik data (seperti data mana yang benar dilabelkannya)
+
+๐ *Recall*: PB/(PB + PP) Rasio titk data relevan yang digunakan, maupun labelnya benar atau tidak.
+
+๐ *f1-score*: (2 * Presisi * *Recall*)/(Presisi + *Recall*) Sebuah rata-rata tertimbang antara presisi dan *recall*. 1 itu baik dan 0 itu buruk.
+
+๐ Dukungan: Jumlah kejadian per label
+
+๐ Akurasi: (PB + NB)/(PB + PS + NB + NS) Persentase label yang diprediksi dengan benar untuk sebuah sampel.
+
+๐ Rata-rata Makro: Hitungan rata-rata sederhana (non-tertimbang) metrik setiap label tanpa menghiraukan ketidakseimbangan label.
+
+๐ Rata-rata Tertimbang: Hitungan rata-rata metrik setiap label dengan mempertimbangkan ketidakseimbangan label. Rata-ratanya tertimbang nilai Dukungan (jumlah kejadian dalam realita) setiap label.
+
+โ
Apa kamu bisa tebak metrik apa yang harus dipantau untuk mengurangi jumlah negatif palsu modelmu?
+## Visualisasikan kurva ROC model ini
+
+Ini bukanlah sebuah model buruk. Akurasinya sekitar 80%, jadi sebenarnya bisa digunakan untuk memprediksi warna sebuah labu berdasarkan beberapa variabel.
+
+Mari kita memvisualisasikan datanya sekali lagi untuk melihat nilai ROC ini:
+
+```python
+from sklearn.metrics import roc_curve, roc_auc_score
+
+y_scores = model.predict_proba(X_test)
+# calculate ROC curve
+fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
+sns.lineplot([0, 1], [0, 1])
+sns.lineplot(fpr, tpr)
+```
+Menggunakan Seaborn lagi, gambarlah [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) (ROC) model ini. Kurva ROC seringkali digunakan untuk menunjukkan output sebuah pembuat klasifikasi berdasarkan jumlah positif benar dan positif palsunya. "Kurva ROC biasanya menetapkan persentase positif benar di sumbu Y dan positif palsunya di sumbu X" (diterjemahkan). Maka, terjalnya kurva ini dan ruang antara garis titik tengah dan kurvanya penting: kamu mau sebuah kurva yang naik ke atas garisnya secepat mungkin. Dalam kasus ini, ada positif palsu di awal, terus kurvanya naik di atas garisnya dengan benar:
+
+
+
+Akhirnya, gunakanlah [API `roc_auc_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) Scikit-learn untuk menghitung 'Area Di Bawah Kurva'-nya (ADBK) secara persis:
+
+```python
+auc = roc_auc_score(y_test,y_scores[:,1])
+print(auc)
+```
+Hasilnya adalah `0.6976998904709748`. Mengingat bahwa ADBK itu antara 0 dan 1, lebih besar ADBK-nya lebih baik sebab ADBK model yang 100% benar terus adalah 1; dalam kasus ini, modelnya _lumayan bagus_.
+
+Nanti dalam pelajaran lebih lanjut tentang klasifikasi, kamu akan belajar bagaimana mengulang untuk membuat nilai-nilai modelmu lebih baik. Tetapi sekian dulu. Selamat! Kamu selesai pelajaran-pelajaran regresi ini!
+
+---
+## ๐ Tantangan
+
+Masih ada banyak tentang regresi logistik! Tetapi cara paling baik adalah untuk bereksperimen. Carilah sebuah *dataset* yang bisa diteliti seperti ini dan bangunlah sebuah model darinya. Apa yang kamu pelajari? Petunjuk: Coba [Kaggle](https://kaggle.com) untuk *dataset-dataset* menarik.
+## [Kuis pasca-ceramah](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/16/)
+
+## Review & Pembelajaran mandiri
+
+Bacalah beberapa halaman pertama [makalah ini dari Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) tentang beberapa penggunaan praktis regresi logistik. Pikirkan tentang tugas-tugas yang lebih baik untuk suatu jenis regresi atau jenis-jenis lainnya yang kita telah pelajari sampai kini. Apa yang akan bekerja paling baik?
+
+## Tugas
+
+[Coba lagi regresi ini](assignment.md)