You already know the basics of preprocessing your data and how to build pipelines. That's great! Now we can move to the fun part, Modeling!  

Let's recap what a **model** is. In Scikit-learn, it is an Estimator that has both `.predict()` and `.score()` methods (and since it is an Estimator, the `.fit()` method is also present).

## .fit() 
Once the data is preprocessed and ready to go to the model, the first step of building a model is **training a model**.  
This is done using the `.fit(X, y)`.
> Note
>
> To train a model performing a supervised learning task (e.g., regression, classification), you need to pass both `X` and `y` to the `.fit()` method.  
If you are dealing with an unsupervised learning task (e.g., clustering), it does not require labeled data, so you can only pass the `X` variable, `.fit(X)`. However, using `.fit(X, y)` will not raise an error. The model will just ignore the `y` variable.  

During the training, a model learns everything it needs to perform predictions.  
What a model learns and how long it will train depends on the algorithm you choose. For each task, there are many models based on different algorithms. Some of them train slower, some – faster.  
But overall, training is usually the most time-consuming thing in Machine Learning, and if the training set is large, a model can train for minutes, hours, or even days.

## .predict()
Once the model is trained using the `.fit()` method, it can perform predictions.  
Predicting is as easy as calling the `.predict()` method:
```python
model.fit(X, y) # Train a model
y_pred = model.predict(X_new) # Get a prediction
```  
Usually, you want to predict a target for new instances, `X_new`.

## .score()
The `.score(X, y)` method is used to measure a trained model's performance. Usually, it is calculated on the **test set** (the following chapters will explain what it is). Here is the syntax:
```python
model.fit(X, y) # Training the model
model.score(X_test, y_test)
``` 
The `.score()` method requires actual target values (`y_test` in the example). It calculates the prediction for `X_test` instances and compares this prediction with the true target (`y_test`) using some metric.  
By default, this metric is **accuracy** for classification.

The next chapter will briefly explain how the `KNeighborsClassifier` model works and what it does during training and predicting.

Machine Learning is now used everywhere. Want to learn it yourself? This course is an introduction to the world of Machine learning for you to learn basic concepts, work with Scikit-learn – the most popular library for ML and build your first Machine Learning project.
This course is intended for students with a basic knowledge of Python, Pandas, and Numpy.

Learn the Machine Learning concepts and the ML project workflow.

Preprocessing is probably the most important stage of an ML project. This chapter covers the preprocessing steps needed for almost any dataset.

A pipeline is a neat way to combine all the preprocessing steps as well as a model. Pipelines make it much easier to train and use a model.

Modeling is the most fun stage of an ML project. Let's learn to build, fine-tune and evaluate the model!

ML Introduction with scikit-learn

Models

.fit()

.predict()

.score()