# Budowanie modelu regresji za pomocą Scikit-learn: regresja na cztery sposoby
## Notatka dla początkujących
Regresja liniowa jest używana, gdy chcemy przewidzieć **wartość liczbową** (na przykład cenę domu, temperaturę lub sprzedaż).
Działa przez znalezienie prostej, która najlepiej reprezentuje związek między cechami wejściowymi a wynikiem.
W tej lekcji skupiamy się na zrozumieniu koncepcji przed eksploracją bardziej zaawansowanych technik regresji.
> Infografika autorstwa [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [Quiz przed wykładem](https://ff-quizzes.netlify.app/en/ml/)
> ### [Ta lekcja jest dostępna w R!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### Wprowadzenie
Dotychczas zapoznawałeś się z pojęciem regresji na przykładowych danych z zestawu danych o cenach dyni, które wykorzystamy w całej tej lekcji. Wizualizowałeś je również za pomocą Matplotlib.
Teraz jesteś gotów, aby zagłębić się bardziej w regresję w ML. Podczas gdy wizualizacja pozwala zrozumieć dane, prawdziwa moc uczenia maszynowego pochodzi z _treningu modeli_. Modele uczą się na danych historycznych, aby automatycznie uchwycić zależności w danych i pozwalają przewidywać wyniki dla nowych danych, których model wcześniej nie widział.
W tej lekcji poznasz dwa rodzaje regresji: _podstawową regresję liniową_ oraz _regresję wielomianową_, wraz z niektórymi aspektami matematycznymi tych technik. Te modele pozwolą nam przewidywać ceny dyni w zależności od różnych danych wejściowych.
[](https://youtu.be/CRxFT8oTDMg "ML dla początkujących - Zrozumienie regresji liniowej")
> 🎥 Kliknij powyższy obraz, aby obejrzeć krótki film wprowadzający do regresji liniowej.
> W całym tym kursie zakładamy minimalną znajomość matematyki i staramy się uczynić ją dostępną dla studentów z innych dziedzin, więc zwracaj uwagę na notatki, 🧮 wskazówki, diagramy i inne narzędzia wspierające naukę.
### Wymagania wstępne
Powinieneś już znać strukturę danych o dyniach, które badamy. Możesz je znaleźć wstępnie załadowane i wstępnie oczyszczone w pliku _notebook.ipynb_ dołączonym do tej lekcji. W pliku cena dyni podawana jest na buszel w nowej ramce danych. Upewnij się, że potrafisz uruchamiać te notatniki w środowisku Visual Studio Code.
### Przygotowanie
Przypominamy, że ładujesz te dane, aby móc zadawać pytania dotyczące tych danych.
- Kiedy jest najlepszy czas na zakup dyni?
- Jaka cena może być oczekiwana za skrzynkę miniaturek?
- Czy powinienem je kupować w połowie buszlowych koszyków czy w kartonie 1 1/9 buszla?
Zanurzmy się głębiej w dane.
W poprzedniej lekcji utworzyłeś ramkę danych Pandas i wypełniłeś ją częścią oryginalnego zestawu danych, standaryzując ceny na buszel. Jednak w ten sposób zebrałeś około 400 punktów danych i tylko za miesiące jesienne.
Spójrz na dane, które wstępnie załadowaliśmy w notatniku towarzyszącym tej lekcji. Dane są już wczytane, a na początek wykreślony jest wykres punktowy pokazujący dane miesięczne. Może uzyskamy trochę więcej szczegółów o charakterze danych, dodatkowo je oczyszczając.
## Linia regresji liniowej
Jak nauczyłeś się w Lekcji 1, celem ćwiczenia z regresji liniowej jest wyrysowanie linii, która:
- **Pokazuje zależności między zmiennymi.** Pokazuje relację między zmiennymi.
- **Umożliwia przewidywania.** Dokonuje dokładnych przewidywań, gdzie nowy punkt danych pojawi się względem tej linii.
Typowo w **regresji najmniejszych kwadratów** rysuje się taki typ linii. Termin "najmniejszych kwadratów" odnosi się do procesu minimalizacji całkowitego błędu w modelu. Dla każdego punktu danych mierzymy pionową odległość (zwaną resztą) pomiędzy rzeczywistym punktem a naszą linią regresji.
Kwadratujemy te odległości z dwóch głównych powodów:
1. **Wielkość ponad kierunkiem:** Chcemy traktować błąd -5 tak samo jak +5. Potęgowanie do kwadratu sprawia, że wszystkie wartości są dodatnie.
2. **Kara dla wartości odstających:** Kwadraty nadają większą wagę większym błędom, zmuszając linię do pozostania bliżej punktów daleko oddalonych.
Następnie sumujemy wszystkie te kwadratowe wartości. Naszym celem jest znalezienie takiej linii, dla której ta suma jest najmniejsza (najmniejsza możliwa wartość)—stąd nazwa "najmniejszych kwadratów".
> **🧮 Pokaż mi matematykę**
>
> Ta linia, zwana _linią najlepszego dopasowania_, może być wyrażona wzorem:
>
> ```
> Y = a + bX
> ```
>
> `X` to "zmienna wyjaśniająca". `Y` to "zmienna zależna". Nachylenie linii to `b`, a `a` to wyraz wolny, czyli wartość `Y` gdy `X = 0`.
>
>
>
> Najpierw obliczamy nachylenie `b`. Infografika [Jen Looper](https://twitter.com/jenlooper)
>
> Innymi słowy, nawiązując do pytania z danych o dyniach: "przewidzieć cenę dyni za buszel w zależności od miesiąca", `X` odnosi się do ceny, a `Y` do miesiąca sprzedaży.
>
>
>
> Oblicz wartość Y. Jeśli płacisz około 4 dolarów, musi być kwiecień! Infografika [Jen Looper](https://twitter.com/jenlooper)
>
> Matematyka obliczająca linię musi uwzględniać nachylenie linii, które jest zależne także od wyrazu wolnego, czyli miejsca przecięcia osi `Y` dla `X = 0`.
>
> Metodę obliczenia tych wartości możesz zobaczyć na stronie [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html). Odwiedź też [kalkulator najmniejszych kwadratów](https://www.mathsisfun.com/data/least-squares-calculator.html), by zobaczyć, jak wartości liczb wpływają na linię.
## Korelacja
Jeszcze jeden termin, który warto zrozumieć, to **współczynnik korelacji** między zmiennymi X i Y. Za pomocą wykresu punktowego możesz szybko zwizualizować ten współczynnik. Wykres z punktami ułożonymi blisko linii ma wysoką korelację, ale wykres z punktami rozrzuconymi wszędzie ma niską korelację.
Dobry model regresji liniowej to taki, którego współczynnik korelacji jest wysoki (bliższy 1 niż 0), używając metody regresji najmniejszych kwadratów z linią regresji.
✅ Uruchom notatnik towarzyszący tej lekcji i spójrz na wykres rozwieślny Miesiąc vs Cena. Czy dane łączące Miesiąc z Ceną dla sprzedaży dyni wydają się mieć wysoką czy niską korelację, według twojej wizualnej interpretacji wykresu? Czy zmienia się to, jeśli zamiast `Miesiąca` użyjesz dokładniejszej miary, np. *dnia roku* (liczba dni od początku roku)?
W poniższym kodzie założymy, że dane zostały już oczyszczone i uzyskano ramkę danych `new_pumpkins` podobną do poniższej:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|-------
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
> Kod do oczyszczenia danych jest dostępny w [`notebook.ipynb`](notebook.ipynb). Wykonaliśmy te same kroki oczyszczenia co w poprzedniej lekcji i wyliczyliśmy kolumnę `DayOfYear` następującym wyrażeniem:
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
Teraz, gdy rozumiemy matematykę stojącą za regresją liniową, stwórzmy model regresji, aby sprawdzić, czy jesteśmy w stanie przewidzieć, który pakiet dyni przyniesie najlepsze ceny. Ktoś kupujący dynie na sezonową dekorację może chcieć mieć tę informację, aby zoptymalizować zakup.
## Szukanie korelacji
[](https://youtu.be/uoRq-lW2eQo "ML dla początkujących - Szukanie korelacji: klucz do regresji liniowej")
> 🎥 Kliknij powyższy obraz, aby obejrzeć krótki film wprowadzający do korelacji.
Z poprzedniej lekcji prawdopodobnie widziałeś, że średnie ceny dla różnych miesięcy wyglądają tak:
Sugeruje to, że powinna istnieć jakaś korelacja i możemy spróbować wytrenować model regresji liniowej, aby przewidzieć związek między `Month` a `Price` lub między `DayOfYear` a `Price`. Oto wykres punktowy pokazujący tę drugą relację:
Sprawdźmy, czy istnieje korelacja, korzystając z funkcji `corr`:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
Wygląda na to, że korelacja jest dość niewielka: -0,15 względem `Month` i -0,17 względem `DayOfMonth`, ale może istnieć inna ważna relacja. Wygląda na to, że różne klastry cen odpowiadają różnym odmianom dyni. Aby potwierdzić tę hipotezę, wyświetlmy każdą kategorię dyni innym kolorem. Przekazując parametr `ax` do funkcji `scatter`, możemy narysować wszystkie punkty na tym samym wykresie:
```python
ax=None
colors = ['red','blue','green','yellow']
for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
Nasze badanie sugeruje, że odmiana dyni ma większy wpływ na cenę niż faktyczna data sprzedaży. Widzimy to na wykresie słupkowym:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
Na razie skupmy się wyłącznie na odmianie 'pie type' i zobaczmy, jaki wpływ na cenę ma data:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
Jeśli teraz obliczymy korelację między `Price` a `DayOfYear` za pomocą funkcji `corr`, otrzymamy coś około `-0.27` – co oznacza, że trenowanie modelu predykcyjnego ma sens.
> Przed trenowaniem modelu regresji liniowej ważne jest, aby upewnić się, że nasze dane są czyste. Regresja liniowa nie działa dobrze z brakującymi wartościami, więc sensowne jest pozbycie się wszystkich pustych komórek:
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
Innym podejściem może być wypełnienie brakujących wartości średnimi wartościami z odpowiedniej kolumny.
## Prosta regresja liniowa
[](https://youtu.be/e4c_UP2fSjg "ML dla początkujących - Regresja liniowa i wielomianowa ze Scikit-learn")
> 🎥 Kliknij powyższy obraz, aby obejrzeć krótki film o regresji liniowej i wielomianowej.
Do treningu naszego modelu regresji liniowej użyjemy biblioteki **Scikit-learn**.
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
Zaczynamy od rozdzielenia wartości wejściowych (cech) i oczekiwanego wyniku (etykiety) do osobnych tablic numpy:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> Zauważ, że musieliśmy wykonać `reshape` na danych wejściowych, aby pakiet Linear Regression mógł je prawidłowo zinterpretować. Regresja liniowa oczekuje 2-wymiarowej tablicy jako danych wejściowych, gdzie każdy wiersz odpowiada wektorowi cech. W naszym przypadku, mając tylko jedną cechę, potrzebujemy tablicy o kształcie N×1, gdzie N to liczba elementów w zestawie danych.
Następnie musimy podzielić dane na zbiory treningowy i testowy, aby móc zweryfikować model po treningu:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
W końcu trening właściwego modelu regresji liniowej zajmuje zaledwie dwie linijki kodu. Definiujemy obiekt `LinearRegression` i dopasowujemy go do danych za pomocą metody `fit`:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
Obiekt `LinearRegression` po dopasowaniu (`fit`) zawiera wszystkie współczynniki regresji, do których można uzyskać dostęp za pomocą właściwości `.coef_`. W naszym przypadku jest tylko jeden współczynnik, który powinien wynosić około `-0.017`. Oznacza to, że ceny wydają się nieco spadać wraz z czasem, ale nieznacznie, około 2 centy dziennie. Możemy również uzyskać punkt przecięcia regresji z osią Y za pomocą `lin_reg.intercept_` – w naszym przypadku będzie to około `21`, co wskazuje na cenę na początku roku.
Aby sprawdzić, jak dokładny jest nasz model, możemy przewidzieć ceny na zestawie testowym, a następnie zmierzyć, jak bliskie są nasze przewidywania do oczekiwanych wartości. Można to zrobić za pomocą metryki błędu średniokwadratowego (MSE), która jest średnią wszystkich kwadratów różnic między wartościami oczekiwanymi a przewidywanymi.
```python
pred = lin_reg.predict(X_test)
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
```
Nasz błąd wydaje się wynosić około 2 punkty, co stanowi ~17%. Niezbyt dobrze. Innym wskaźnikiem jakości modelu jest **współczynnik determinacji**, który można uzyskać w ten sposób:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
Jeśli wartość wynosi 0, oznacza to, że model nie uwzględnia danych wejściowych i działa jako *najgorszy liniowy predyktor*, czyli po prostu wartość średnia wyniku. Wartość 1 oznacza, że możemy idealnie przewidzieć wszystkie oczekiwane wyniki. W naszym przypadku współczynnik wynosi około 0,06, co jest dość niskie.
Możemy również narysować dane testowe wraz z linią regresji, aby lepiej zobaczyć, jak działa regresja w naszym przypadku:
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
## Regresja wielomianowa
Innym typem regresji liniowej jest regresja wielomianowa. Chociaż czasami istnieje liniowa zależność między zmiennymi – im większa dynia pod względem objętości, tym wyższa cena – czasem te zależności nie mogą być przedstawione jako płaszczyzna lub prosta.
✅ Oto [kilka dodatkowych przykładów](https://online.stat.psu.edu/stat501/lesson/9/9.8) danych, które mogłyby korzystać z regresji wielomianowej
Spójrz ponownie na związek między Datą a Ceną. Czy ten wykres punktowy musi być koniecznie analizowany linią prostą? Czy ceny nie mogą się wahać? W takim przypadku możesz spróbować regresji wielomianowej.
✅ Wielomiany to wyrażenia matematyczne, które mogą składać się z jednej lub więcej zmiennych i współczynników
Regresja wielomianowa tworzy krzywą linię, aby lepiej dopasować dane nieliniowe. W naszym przypadku, jeśli do danych wejściowych dodamy zmienną `DayOfYear` podniesioną do kwadratu, powinniśmy być w stanie dopasować nasze dane paraboliczną krzywą, która będzie miała minimum w określonym punkcie roku.
Scikit-learn zawiera przydatne [API potoku](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline), aby połączyć różne etapy przetwarzania danych razem. **Potok** to łańcuch **estymatorów**. W naszym przypadku stworzymy potok, który najpierw dodaje cechy wielomianowe do modelu, a następnie trenuje regresję:
```python
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
Użycie `PolynomialFeatures(2)` oznacza, że uwzględnimy wszystkie wielomiany stopnia drugiego z danych wejściowych. W naszym przypadku oznacza to tylko `DayOfYear`2, ale mając dwie zmienne wejściowe X i Y, dodane zostaną X2, XY i Y2. Możemy również użyć wielomianów wyższego stopnia, jeśli chcemy.
Potoki mogą być używane tak samo jak oryginalny obiekt `LinearRegression`, czyli możemy `fit` potok, a następnie użyć `predict`, aby uzyskać wyniki predykcji. Oto wykres pokazujący dane testowe i krzywą aproksymacji:
Używając regresji wielomianowej, możemy uzyskać nieco niższy MSE i wyższy współczynnik determinacji, ale nieznacznie. Musimy uwzględnić inne cechy!
> Widać, że minimalne ceny dyń obserwowane są gdzieś około Halloween. Jak możesz to wytłumaczyć?
🎃 Gratulacje, właśnie stworzyłeś model, który może pomóc przewidywać ceny dyń na ciasto. Prawdopodobnie możesz powtórzyć tę samą procedurę dla wszystkich typów dyń, ale byłoby to czasochłonne. Nauczmy się teraz, jak uwzględnić odmianę dyni w naszym modelu!
## Cechy kategoryczne
W idealnym świecie chcielibyśmy być w stanie przewidywać ceny różnych odmian dyni za pomocą tego samego modelu. Jednak kolumna `Variety` jest nieco inna niż kolumny takie jak `Month`, ponieważ zawiera wartości nienumeryczne. Takie kolumny nazywają się **kategorycznymi**.
[](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 Kliknij powyższy obraz, aby obejrzeć krótki film o używaniu cech kategorycznych.
Tutaj możesz zobaczyć, jak średnia cena zależy od odmiany:
Aby uwzględnić odmianę, najpierw musimy przekonwertować ją na formę numeryczną, czyli **zakodować**. Istnieje kilka sposobów, aby to zrobić:
* Proste **kodowanie numeryczne** zbuduje tabelę różnych odmian, a następnie zastąpi nazwę odmiany indeksem w tej tabeli. Nie jest to najlepszy pomysł dla regresji liniowej, ponieważ regresja liniowa bierze rzeczywistą wartość numeryczną indeksu i dodaje ją do wyniku, mnożąc przez pewien współczynnik. W naszym przypadku zależność między numerem indeksu a ceną jest wyraźnie nieliniowa, nawet jeśli upewnimy się, że indeksy są uporządkowane w określony sposób.
* **Kodowanie one-hot** zastąpi kolumnę `Variety` 4 różnymi kolumnami, po jednej dla każdej odmiany. Każda kolumna będzie zawierać `1`, jeśli odpowiadający wiersz jest danej odmiany, i `0` w przeciwnym razie. Oznacza to, że w regresji liniowej pojawią się cztery współczynniki, po jednym dla każdej odmiany dyni, odpowiadające "cenie startowej" (a raczej "dodatkowej cenie") za tę konkretną odmianę.
Poniższy kod pokazuje, jak możemy zakodować odmianę metodą one-hot:
```python
pd.get_dummies(new_pumpkins['Variety'])
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
----|-----------|-----------|--------------------------|----------
70 | 0 | 0 | 0 | 1
71 | 0 | 0 | 0 | 1
... | ... | ... | ... | ...
1738 | 0 | 1 | 0 | 0
1739 | 0 | 1 | 0 | 0
1740 | 0 | 1 | 0 | 0
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
Aby wytrenować regresję liniową używając one-hot zakodowanej odmiany jako dane wejściowe, po prostu musimy poprawnie zainicjalizować dane `X` i `y`:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
Reszta kodu jest taka sama, jaką użyliśmy wcześniej do trenowania regresji liniowej. Jeśli spróbujesz, zobaczysz, że błąd średniokwadratowy jest mniej więcej taki sam, ale uzyskujemy znacznie wyższy współczynnik determinacji (~77%). Aby uzyskać jeszcze dokładniejsze przewidywania, możemy uwzględnić więcej cech kategorycznych oraz cechy numeryczne, takie jak `Month` czy `DayOfYear`. Aby uzyskać jedną dużą tablicę cech, możemy użyć `join`:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
Tutaj bierzemy również pod uwagę `City` i typ `Package`, co daje nam MSE 2.84 (10%) i determinację 0.94!
## Łączenie wszystkiego w całość
Aby stworzyć najlepszy model, możemy użyć połączonych danych (zakodowane one-hot kategorie + dane numeryczne) z powyższego przykładu wraz z regresją wielomianową. Oto kompletny kod dla wygody:
```python
# przygotuj dane treningowe
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# wykonaj podział na zbiór treningowy i testowy
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# skonfiguruj i wytrenuj potok
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# przewiduj wyniki dla danych testowych
pred = pipeline.predict(X_test)
# oblicz błąd średniokwadratowy i współczynnik determinacji
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
Powinno to dać nam najlepszy współczynnik determinacji prawie 97% oraz MSE=2.23 (~8% błąd predykcji).
| Model | MSE | Determinacja |
|-------|-----|--------------|
| Regresja liniowa `DayOfYear` | 2.77 (17.2%) | 0.07 |
| Regresja wielomianowa `DayOfYear` | 2.73 (17.0%) | 0.08 |
| Regresja liniowa `Variety` | 5.24 (19.7%) | 0.77 |
| Regresja liniowa dla wszystkich cech | 2.84 (10.5%) | 0.94 |
| Regresja wielomianowa dla wszystkich cech | 2.23 (8.25%) | 0.97 |
🏆 Świetna robota! Stworzyłeś cztery modele regresji w jednej lekcji i poprawiłeś jakość modelu do 97%. W ostatniej części dotyczącej regresji nauczysz się o regresji logistycznej do określania kategorii.
---
## 🚀Wyzwanie
Przetestuj kilka różnych zmiennych w tym notatniku, aby zobaczyć, jak korelacja odpowiada dokładności modelu.
## [Quiz po wykładzie](https://ff-quizzes.netlify.app/en/ml/)
## Powtórka i samodzielna nauka
W tej lekcji nauczyliśmy się o regresji liniowej. Istnieją inne ważne typy regresji. Przeczytaj o technikach Stepwise, Ridge, Lasso i Elasticnet. Dobrym kursem do nauki jest [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## Zadanie
[Zbuduj Model](assignment.md)
---
**Zastrzeżenie**:
Niniejszy dokument został przetłumaczony za pomocą usługi tłumaczenia AI [Co-op Translator](https://github.com/Azure/co-op-translator). Mimo że dążymy do dokładności, prosimy pamiętać, że tłumaczenia automatyczne mogą zawierać błędy lub nieścisłości. Oryginalny dokument w języku źródłowym powinien być traktowany jako źródło autorytatywne. W przypadku istotnych informacji zalecane jest skorzystanie z profesjonalnego tłumaczenia wykonywanego przez człowieka. Nie ponosimy odpowiedzialności za jakiekolwiek nieporozumienia lub błędne interpretacje wynikające z korzystania z tego tłumaczenia.