The **Scikit-learn** (imported as `sklearn`) library offers various functions and classes for preprocessing data and modeling.  
The main `sklearn` objects are **estimator**, **transformer**, **predictor**, and **model**.  
Let's examine each of those.

### Estimator
Each `sklearn`'s class with the `.fit()` method is considered an **estimator**.  
The `.fit()` method allows an object to learn from the data.  
In other words, the `.fit()` method is for **training an object**.  
It takes `X` and `y` parameters (`y` is optional for unsupervised learning tasks). The syntax:
```python
estimator.fit(X, y) # For supervised learning tasks
estimator.fit(X) # For unsupervised learning tasks
```

As you can tell, that's not really helpful if an object only learns from data and does nothing with it. But the two objects, the transformer and predictor, that inherit from the estimator are much more useful. Let's start with the transformer.

### Transformer
A **transformer** has the `.fit()` method and the `.transform()` method that transforms the data in some way.  
Usually, transformers need to learn something from data before transforming it, so you need to apply `.fit()` and then `.transform()`. To avoid that, transformers also have the `.fit_transform()` method.  
`.fit_transform()` leads to the same result as applying `.fit()` and `.transform()` sequentially, but is sometimes faster, so it is preferable over `.fit().transform()`.  
The syntax is:
```python
transformer.fit(X) # Train the transformer
transformer.transform(X) # Transform the data using an already trained transformer
transformer.fit_transform(X) # Train the transformer and transform the data
```
> Note
> 
> Transformers are usually used to transform the `X` array. However, as we will see in the example of `LabelEncoder`, some transformers are made for the `y` array.

### Predictor
A **predictor** is an estimator(has the `.fit()` method) that has the `.predict()` method.  
The `.predict()` method is used for making predictions. The syntax:
```python
predictor.fit(X, y) # Training the predictor
predictor.predict(X_new) # Predicting the target for new instances once the predictor is trained. 
```

### Model
A **model** is a predictor that also has the `.score()` method.  
The `.score()` method calculates a score (metric) to measure the predictor's performance. The syntax is:
```python
model.fit(X, y) # Train the model
model.score(X, y) # Calculate a score for the trained model on X, y set.
```

Here is a table to sum up:
| **Type of class** | **Required methods** |
|---- | --- |
| Estimator | `.fit()` |
| Transformer | `.fit()`, `.transform()`, `.fit_transform()`|
| Predictor | `.fit()`, `.predict()`|
| Model | `.fit()`, `.predict()`, `.score()`|

The **preprocessing** stage involves working with Transformers, and we work with Predictors (more specifically with Models) at the **modeling** stage.

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!

Type of class	Required methods
Estimator	`.fit()`
Transformer	`.fit()`, `.transform()`, `.fit_transform()`
Predictor	`.fit()`, `.predict()`
Model	`.fit()`, `.predict()`, `.score()`

ML Introduction with scikit-learn

Scikit-learn Concepts

Estimator

Transformer

Predictor

Model

Select all correct statements.

Select a few correct answers