Uczenie maszynowe w Pythonie. Deep learning i machine learning - ebook

Spis treści

1. Wprowadzenie do uczenia maszynowego

1.1. Czym jest uczenie maszynowe?

1.2. Historia uczenia maszynowego

1.3. Zastosowania uczenia maszynowego

1.4. Rodzaje uczenia maszynowego

1.5. Wyzwania i ograniczenia

2. Podstawy Pythona dla uczenia maszynowego

2.1. Instalacja i konfiguracja środowiska

2.2. Struktury danych w Pythonie

2.3. Funkcje i klasy

2.4. Operacje na plikach

2.5. Obsługa wyjątków

3. Biblioteki Pythona do uczenia maszynowego

3.1. NumPy

3.2. Pandas

3.3. Matplotlib i Seaborn

3.4. Scikit-learn

3.5. TensorFlow i Keras

4. Przygotowanie i przetwarzanie danych

4.1. Importowanie danych

4.2. Czyszczenie danych

4.3. Obsługa brakujących wartości

4.4. Kodowanie zmiennych kategorycznych

4.5. Normalizacja i standaryzacja

4.6. Podział danych na zbiory treningowe i testowe

5. Uczenie nadzorowane: Regresja

5.1. Regresja liniowa

5.2. Regresja wielomianowa

5.3. Regresja grzbietowa i LASSO

5.4. Drzewa regresyjne

5.5. Ocena modeli regresyjnych

6. Uczenie nadzorowane: Klasyfikacja

6.1. Regresja logistyczna

6.2. Naiwny klasyfikator Bayesa

6.3. K najbliższych sąsiadów (KNN)

6.4. Drzewa decyzyjne

6.5. Ocena modeli klasyfikacyjnych

7. Uczenie nienadzorowane: Grupowanie

7.1. Algorytm K-średnich

7.2. Grupowanie hierarchiczne

7.3. DBSCAN

7.4. Ocena jakości grupowania

7.5. Zastosowania grupowania

8. Uczenie nienadzorowane: Redukcja wymiarowości

8.1. Analiza głównych składowych (PCA)

8.2. Analiza składowych niezależnych (ICA)

8.3. t-SNE

8.4. Autoenkodery

8.5. Zastosowania redukcji wymiarowości

9. Sieci neuronowe i głębokie uczenie

9.1. Podstawy sieci neuronowych

9.2. Funkcje aktywacji

9.3. Propagacja wsteczna

9.4. Konwolucyjne sieci neuronowe

9.5. Rekurencyjne sieci neuronowe

9.6. Transfer learning

10. Drzewa decyzyjne i lasy losowe

10.1. Budowa drzew decyzyjnych

10.2. Przycinanie drzew

10.3. Lasy losowe

10.4. Gradient Boosting

10.5. XGBoost i LightGBM

11. Maszyny wektorów nośnych (SVM)

11.1. Liniowe SVM

11.2. Nieliniowe SVM i funkcje jądra

11.3. SVM dla klasyfikacji wieloklasowej

11.4. SVM dla regresji

11.5. Optymalizacja hiperparametrów SVM

12. Ocena i dostrajanie modeli

12.1. Metryki oceny modeli

12.2. Walidacja krzyżowa

12.3. Przeszukiwanie siatki i losowe przeszukiwanie

12.4. Regularyzacja

12.5. Zapobieganie przeuczeniu

13. Przetwarzanie języka naturalnego

13.1. Tokenizacja i lematyzacja

13.2. Reprezentacja tekstu (bag-of-words, TF-IDF)

13.3. Word embeddings

13.4. Analiza sentymentu

13.5. Modele sekwencyjne w NLP

14. Uczenie ze wzmocnieniem

14.1. Podstawy uczenia ze wzmocnieniem

14.2. Algorytmy Q-learning i SARSA

14.3. Metody policy gradient

14.4. Deep Q-Networks (DQN)

14.5. Zastosowania uczenia ze wzmocnieniem

15. Wdrażanie modeli uczenia maszynowego

15.1. Serializacja modeli

15.2. REST API dla modeli ML

15.3. Konteneryzacja z Dockerem

15.4. Wdrażanie w chmurze

15.5. Monitorowanie i aktualizacja modeli2.1. Instalacja i konfiguracja środowiska

2.1. Instalacja i konfiguracja środowiska

Instalacja Pythona

Python to język programowania, który jest szeroko stosowany w dziedzinie uczenia maszynowego. Przed rozpoczęciem pracy z Pythonem, musimy go zainstalować na naszym komputerze. Proces instalacji różni się w zależności od systemu operacyjnego, dlatego omówimy go osobno dla systemów Windows, macOS i Linux.

Instalacja na systemie Windows:

1. Odwiedź oficjalną stronę Pythona (python.org) i przejdź do sekcji "Downloads".

2. Wybierz najnowszą stabilną wersję Pythona dla systemu Windows (np. Python 3.9.x).

3. Pobierz instalator (plik .exe) odpowiedni dla Twojego systemu (32-bitowy lub 64-bitowy).

4. Uruchom pobrany instalator.

5. Zaznacz opcję "Add Python to PATH" podczas instalacji, aby móc łatwo uruchamiać Pythona z wiersza poleceń.

6. Wybierz opcję "Install Now" dla standardowej instalacji lub "Customize installation" dla zaawansowanych opcji.

7. Poczekaj, aż proces instalacji się zakończy.

Instalacja na systemie macOS:

1. Większość systemów macOS ma już preinstalowanego Pythona, ale zazwyczaj jest to starsza wersja.

2. Aby zainstalować najnowszą wersję, odwiedź oficjalną stronę Pythona (python.org).

3. Przejdź do sekcji "Downloads" i wybierz najnowszą stabilną wersję dla macOS.

4. Pobierz instalator (plik .pkg).

5. Uruchom pobrany instalator i postępuj zgodnie z instrukcjami na ekranie.

6. Po zakończeniu instalacji, Python będzie dostępny w Terminalu.

Alternatywnie, możesz użyć menedżera pakietów Homebrew do instalacji Pythona:

1. Zainstaluj Homebrew, jeśli jeszcze go nie masz.

2. Otwórz Terminal i wpisz komendę: brew install python

Instalacja na systemie Linux:

Większość dystrybucji Linuxa ma już preinstalowanego Pythona. Jednak jeśli chcesz zainstalować najnowszą wersję, możesz to zrobić na kilka sposobów, w zależności od dystrybucji:

Dla Ubuntu i innych dystrybucji opartych na Debianie:

1. Otwórz terminal.

2. Zaktualizuj listę pakietów: sudo apt update

3. Zainstaluj Pythona: sudo apt install python3

Dla Fedora:

1. Otwórz terminal.

2. Zainstaluj Pythona: sudo dnf install python3

Dla Arch Linux:

1. Otwórz terminal.

2. Zainstaluj Pythona: sudo pacman -S python

Alternatywnie, możesz skompilować Pythona ze źródeł:

1. Pobierz kod źródłowy z oficjalnej strony Pythona.

2. Rozpakuj archiwum.

3. Przejdź do katalogu z rozpakowanymi plikami.

4. Uruchom komendy: ./configure make sudo make install

Różnice między wersjami Pythona:

Python ma dwie główne gałęzie rozwojowe: Python 2 i Python 3. Python 2 nie jest już oficjalnie wspierany od 1 stycznia 2020 roku, dlatego zaleca się korzystanie z Pythona 3.

Główne różnice między Python 2 a Python 3:

1. Składnia print: W Python 2 print jest instrukcją, w Python 3 jest funkcją.

2. Dzielenie liczb całkowitych: W Python 2 dzielenie dwóch liczb całkowitych zawsze daje wynik całkowity, w Python 3 daje wynik zmiennoprzecinkowy.

3. Kodowanie znaków: Python 3 domyślnie używa UTF-8, co ułatwia pracę z różnymi językami.

4. Funkcja input(): W Python 2 używano raw\_input() do pobierania danych jako ciągu znaków, w Python 3 funkcja input() spełnia tę rolę.

5. Iteratory: W Python 3 wiele funkcji, które wcześniej zwracały listy, teraz zwracają iteratory, co poprawia wydajność.

W kontekście uczenia maszynowego, zaleca się korzystanie z najnowszej stabilnej wersji Pythona 3. Większość popularnych bibliotek do uczenia maszynowego, takich jak NumPy, SciPy, Pandas, Scikit-learn czy TensorFlow, jest kompatybilna z Pythonem 3 i aktywnie rozwijana dla tej wersji.

Warto zauważyć, że nawet w obrębie Pythona 3 istnieją różne wersje (np. 3.7, 3.8, 3.9). Każda nowa wersja wprowadza pewne usprawnienia i nowe funkcjonalności. Przy wyborze wersji Pythona do projektu uczenia maszynowego, należy wziąć pod uwagę kompatybilność z używanymi bibliotekami. Niektóre biblioteki mogą wymagać konkretnej wersji Pythona lub mogą nie być jeszcze w pełni kompatybilne z najnowszymi wersjami.

Po zainstalowaniu Pythona, możesz sprawdzić jego wersję, otwierając terminal (lub wiersz poleceń w Windows) i wpisując komendę:

python --version

lub

python3 --version

To pozwoli Ci upewnić się, że instalacja przebiegła pomyślnie i że masz dostęp do właściwej wersji Pythona.

Pamiętaj, że w przypadku uczenia maszynowego, sama instalacja Pythona to dopiero początek. W kolejnych krokach będziemy konfigurować środowisko pracy, instalować niezbędne biblioteki i narzędzia, które umożliwią nam efektywną pracę nad projektami z zakresu uczenia maszynowego.

Środowiska wirtualne

Środowiska wirtualne są kluczowym narzędziem w pracy z Pythonem, szczególnie w kontekście uczenia maszynowego. Pozwalają one na izolację projektów i zarządzanie zależnościami, co jest niezwykle istotne w przypadku złożonych projektów.

Czym są środowiska wirtualne?

Środowisko wirtualne to izolowana kopia Pythona wraz z własnymi bibliotekami i zależnościami. Dzięki temu możemy tworzyć oddzielne środowiska dla różnych projektów, unikając konfliktów między wersjami bibliotek.

Zalety korzystania ze środowisk wirtualnych:

1. Izolacja projektów: Każdy projekt może mieć własne, niezależne zależności.

2. Łatwiejsze zarządzanie wersjami bibliotek: Możemy używać różnych wersji tej samej biblioteki w różnych projektach.

3. Czystość systemu: Unikamy zaśmiecania globalnej instalacji Pythona.

4. Łatwość reprodukcji środowiska: Możemy łatwo odtworzyć środowisko projektu na innym komputerze.

Narzędzia do tworzenia środowisk wirtualnych:

1. venv

venv to moduł wbudowany w Pythona od wersji 3.3. Jest to najprostsze i najczęściej używane narzędzie do tworzenia środowisk wirtualnych.

Tworzenie środowiska wirtualnego za pomocą venv:

python3 -m venv nazwa_srodowiska

Aktywacja środowiska:

* Na systemach Unix lub MacOS:

source nazwa_srodowiska/bin/activate

* Na Windows:

nazwa_srodowiska\Scripts\activate

Deaktywacja środowiska:

deactivate

2. conda

Conda to system zarządzania pakietami i środowiskami, szczególnie popularny w społeczności data science. Conda może zarządzać zarówno pakietami Pythona, jak i zależnościami spoza ekosystemu Pythona.

Instalacja Condy:

* Pobierz i zainstaluj Anacondę lub Minicondę ze strony oficjalnej.

Tworzenie środowiska za pomocą Condy:

conda create --name nazwa_srodowiska python=3.8

Aktywacja środowiska Conda:

* Na systemach Unix lub MacOS:

conda activate nazwa_srodowiska

* Na Windows:

activate nazwa_srodowiska

Deaktywacja środowiska Conda:

conda deactivate

Zarządzanie środowiskami wirtualnymi:

1. Listowanie zainstalowanych pakietów:

* W venv: `pip list`

* W conda: `conda list`

2. Instalacja pakietów:

* W venv: `pip install nazwa_pakietu`

* W conda: `conda install nazwa_pakietu` lub `pip install nazwa_pakietu`

3. Eksport zależności:

* W venv: `pip freeze > requirements.txt`

* W conda: `conda env export > environment.yml`

4. Odtwarzanie środowiska:

* W venv: `pip install -r requirements.txt`

* W conda: `conda env create -f environment.yml`

Wybór między venv a conda:

* venv jest prostszy i wbudowany w Pythona, co czyni go dobrym wyborem dla projektów czysto pythonowych.

* conda jest bardziej zaawansowany i lepiej radzi sobie z zależnościami spoza ekosystemu Pythona, co jest często przydatne w projektach związanych z uczeniem maszynowym i analizą danych.

Dobre praktyki:

1. Twórz nowe środowisko wirtualne dla każdego projektu.

2. Zawsze aktywuj odpowiednie środowisko przed rozpoczęciem pracy nad projektem.

3. Regularnie aktualizuj plik z zależnościami (requirements.txt lub environment.yml).

4. Nie zapomnij o dodaniu plików środowiska wirtualnego do .gitignore, jeśli korzystasz z systemu kontroli wersji.

Korzystanie ze środowisk wirtualnych jest niezbędne w profesjonalnym rozwoju oprogramowania, szczególnie w dziedzinie uczenia maszynowego, gdzie często pracujemy z wieloma bibliotekami o specyficznych wersjach. Pozwala to na utrzymanie porządku w projektach, uniknięcie konfliktów między zależnościami i ułatwia współpracę z innymi programistami.

Instalacja podstawowych bibliotek do uczenia maszynowego

W dziedzinie uczenia maszynowego w Pythonie, istnieje kilka kluczowych bibliotek, które stanowią fundament większości projektów. Trzy najważniejsze to NumPy, Pandas i Scikit-learn. W tej sekcji skupimy się na ich instalacji.

Metody instalacji:

Istnieją dwie główne metody instalacji bibliotek Pythona: przy użyciu pip (Python Package Installer) lub conda (jeśli korzystamy z dystrybucji Anaconda lub Miniconda). Obie metody mają swoje zalety i są powszechnie stosowane w społeczności Pythona.

1. Instalacja przy użyciu pip:

pip to domyślny menedżer pakietów dla Pythona. Jest on instalowany automatycznie wraz z Pythonem w wersji 3.4 i nowszych.

Instalacja NumPy:

pip install numpy

Instalacja Pandas:

pip install pandas

Instalacja Scikit-learn:

pip install scikit-learn

Możemy również zainstalować wszystkie trzy biblioteki jednocześnie:

pip install numpy pandas scikit-learn

2. Instalacja przy użyciu conda:

Conda to system zarządzania pakietami i środowiskami, który jest częścią dystrybucji Anaconda. Jest szczególnie popularny w społeczności data science ze względu na łatwość zarządzania zależnościami, także tymi spoza ekosystemu Pythona.

Instalacja NumPy:

conda install numpy

Instalacja Pandas:

conda install pandas

Instalacja Scikit-learn:

conda install scikit-learn

Możemy również zainstalować wszystkie trzy biblioteki jednocześnie:

conda install numpy pandas scikit-learn

Wersje bibliotek:

Podczas instalacji bibliotek, możemy określić konkretną wersję, którą chcemy zainstalować. Jest to przydatne, gdy pracujemy nad projektem wymagającym specyficznej wersji biblioteki.

Przykład instalacji konkretnej wersji NumPy przy użyciu pip:

pip install numpy==1.19.5

Przykład instalacji konkretnej wersji Pandas przy użyciu conda:

conda install pandas=1.2.4

Aktualizacja bibliotek:

Aby zaktualizować bibliotekę do najnowszej wersji, możemy użyć następujących komend:

Dla pip:

pip install --upgrade numpy

pip install --upgrade pandas

pip install --upgrade scikit-learn

Dla conda:

conda update numpy

conda update pandas

conda update scikit-learn

Weryfikacja instalacji:

Po zainstalowaniu bibliotek, warto sprawdzić, czy instalacja przebiegła pomyślnie. Możemy to zrobić, importując biblioteki w interaktywnej sesji Pythona:

import numpy as np

import pandas as pd

from sklearn import __version__ as sklearn_version

print(f"NumPy version: {np.__version__}")

print(f"Pandas version: {pd.__version__}")

print(f"Scikit-learn version: {sklearn_version}")

Jeśli powyższy kod wykonuje się bez błędów i wyświetla wersje bibliotek, oznacza to, że instalacja zakończyła się sukcesem.

Instalacja w środowisku wirtualnym:

Zaleca się instalowanie bibliotek w środowisku wirtualnym, a nie w globalnej instalacji Pythona. Przed instalacją bibliotek należy aktywować odpowiednie środowisko wirtualne.

Dla venv:

source nazwa_srodowiska/bin/activate # Unix lub MacOS

nazwa_srodowiska\Scripts\activate # Windows

Dla conda:

conda activate nazwa_srodowiska

Po aktywacji środowiska możemy przystąpić do instalacji bibliotek za pomocą pip lub conda, jak opisano wcześniej.

Pliki wymagań:

W przypadku projektów z wieloma zależnościami, warto utworzyć plik requirements.txt (dla pip) lub environment.yml (dla conda), który zawiera listę wszystkich wymaganych bibliotek wraz z ich wersjami.

Przykładowy plik requirements.txt:

numpy==1.21.0

pandas==1.3.0

scikit-learn==0.24.2

Instalacja z pliku requirements.txt:

pip install -r requirements.txt

Przykładowy plik environment.yml:

name: ml_project

dependencies:

- python=3.8

- numpy=1.21.0

- pandas=1.3.0

- scikit-learn=0.24.2

Tworzenie środowiska i instalacja z pliku environment.yml:

conda env create -f environment.yml

Korzystanie z plików wymagań ułatwia reprodukcję środowiska projektu na innych komputerach i zapewnia spójność wersji bibliotek w zespole.

Narzędzia do interaktywnego programowania w Pythonie

W kontekście uczenia maszynowego, interaktywne środowiska programistyczne odgrywają kluczową rolę. Dwa najpopularniejsze narzędzia w tej kategorii to Jupyter Notebook i Google Colab. Oba umożliwiają pisanie i wykonywanie kodu w sposób interaktywny, co jest szczególnie przydatne w procesie analizy danych i tworzenia modeli uczenia maszynowego.

Jupyter Notebook

Jupyter Notebook to open-source'owe narzędzie, które pozwala na tworzenie i udostępnianie dokumentów zawierających kod, wyniki jego wykonania, wizualizacje i tekst opisowy.

Instalacja Jupyter Notebook:

pip install jupyter

Uruchamianie Jupyter Notebook:

jupyter notebook

Główne cechy Jupyter Notebook:

1. Interaktywność: Kod może być wykonywany w małych fragmentach (komórkach), co ułatwia debugowanie i iteracyjne podejście do analizy danych.

2. Mieszanie kodu i tekstu: Możliwość dodawania komórek z tekstem formatowanym w Markdown, co pozwala na tworzenie czytelnej dokumentacji bezpośrednio w notebooku.

3. Wizualizacje: Wykresy i wizualizacje są wyświetlane bezpośrednio pod kodem, który je generuje.

4. Wsparcie dla wielu języków: Chociaż najczęściej używany jest z Pythonem, Jupyter obsługuje również inne języki, takie jak R czy Julia.

5. Eksport do różnych formatów: Notebooki można eksportować do HTML, PDF, czy nawet slajdów prezentacji.

Google Colab

Google Colab (Colaboratory) to darmowe środowisko do programowania w chmurze oparte na Jupyter Notebook, oferowane przez Google.

Główne cechy Google Colab:

1. Dostęp przez przeglądarkę: Nie wymaga instalacji na lokalnym komputerze.

2. Darmowe zasoby obliczeniowe: Oferuje bezpłatny dostęp do GPU i TPU, co jest szczególnie przydatne w uczeniu maszynowym.

3. Integracja z Google Drive: Łatwe zapisywanie i udostępnianie notebooków.

4. Preinstalowane biblioteki: Wiele popularnych bibliotek do uczenia maszynowego jest już zainstalowanych.

5. Współpraca w czasie rzeczywistym: Możliwość jednoczesnej pracy wielu osób nad tym samym notebookiem.

Zalety interaktywnych środowisk w kontekście uczenia maszynowego:

1. Eksploracja danych: Łatwe wczytywanie, przeglądanie i wizualizacja danych.

2. Iteracyjne tworzenie modeli: Możliwość szybkiego testowania różnych podejść i parametrów.

3. Dokumentacja procesu: Mieszanie kodu, wyników i opisów tekstowych pozwala na tworzenie kompleksowej dokumentacji projektu.

4. Reprodukowalność: Notebooki zawierają cały proces analizy, co ułatwia reprodukcję wyników.

5. Prezentacja wyników: Łatwe tworzenie czytelnych raportów z analizy danych i wyników modeli.

6. Nauka i dydaktyka: Idealne narzędzia do nauki i nauczania uczenia maszynowego.

7. Prototypowanie: Szybkie testowanie pomysłów i koncepcji przed implementacją w pełnym projekcie.

Wybór między Jupyter Notebook a Google Colab:

* Jupyter Notebook jest idealny dla lokalnej pracy i projektów, które wymagają dostępu do lokalnych zasobów.

* Google Colab jest świetnym wyborem dla projektów, które wymagają dużej mocy obliczeniowej (GPU/TPU) lub gdy chcemy łatwo udostępniać i współpracować nad notebookami.

Rozpoczęcie pracy:

Z Jupyter Notebook:

1. Zainstaluj Jupyter: `pip install jupyter`

2. Uruchom w terminalu: `jupyter notebook`

3. W przeglądarce otworzy się interfejs Jupyter, gdzie możesz tworzyć nowe notebooki.

Z Google Colab:

1. Wejdź na stronę colab.research.google.com

2. Zaloguj się na konto Google

3. Wybierz opcję utworzenia nowego notebooka lub otwórz istniejący

W obu przypadkach, po utworzeniu nowego notebooka, możesz zacząć pisać kod w komórkach i wykonywać go, klikając przycisk "Run" lub używając skrótu klawiszowego (zazwyczaj Shift+Enter).

Korzystanie z interaktywnych środowisk programistycznych znacząco usprawnia proces uczenia maszynowego, od wstępnej analizy danych, przez tworzenie i testowanie modeli, aż po prezentację wyników. Zarówno Jupyter Notebook, jak i Google Colab oferują potężne narzędzia, które stały się standardem w społeczności data science i uczenia maszynowego.

2.2. Struktury danych w Pythonie

2.2. Struktury danych w Pythonie

Podstawowe typy danych w Pythonie

Python oferuje kilka podstawowych typów danych, które są niezbędne w codziennym programowaniu, a także w kontekście uczenia maszynowego. Cztery najważniejsze typy to: int (liczby całkowite), float (liczby zmiennoprzecinkowe), str (ciągi znaków) oraz bool (wartości logiczne).

1. int (Integer) - Liczby całkowite

Typ int reprezentuje liczby całkowite, zarówno dodatnie, jak i ujemne, bez części ułamkowej. W Pythonie 3, typ int nie ma ograniczenia co do wielkości liczby, co oznacza, że możemy pracować z bardzo dużymi liczbami całkowitymi.

Przykłady deklaracji zmiennych typu int:

a = 5

b = -10

c = 1000000

Operacje na liczbach całkowitych:

* Dodawanie: `a + b`

* Odejmowanie: `a - b`

* Mnożenie: `a * b`

* Dzielenie całkowite: `a // b` (wynik jest zawsze liczbą całkowitą, zaokrągloną w dół)

* Dzielenie z resztą (modulo): `a % b`

* Potęgowanie: `a ** b`

Python automatycznie konwertuje wynik operacji na typ int, jeśli jest to możliwe:

x = 5 + 3 # x będzie typu int

y = 10 * 2 # y będzie typu int

Funkcje wbudowane dla typu int:

* `abs(x)` - zwraca wartość bezwzględną liczby x

* `pow(x, y)` - podnosi x do potęgi y

* `round(x)` - zaokrągla liczbę x do najbliższej liczby całkowitej

2. float (Floating-point) - Liczby zmiennoprzecinkowe

Typ float reprezentuje liczby rzeczywiste, czyli liczby z częścią ułamkową. W Pythonie liczby zmiennoprzecinkowe są reprezentowane zgodnie ze standardem IEEE 754, co oznacza, że mają ograniczoną precyzję.

Przykłady deklaracji zmiennych typu float:

a = 3.14

b = -0.5

c = 2.0

d = 1e-3 # notacja naukowa: 0.001

Operacje na liczbach zmiennoprzecinkowych:

* Dodawanie: `a + b`

* Odejmowanie: `a - b`

* Mnożenie: `a * b`

* Dzielenie: `a / b` (wynik zawsze jest typu float)

* Potęgowanie: `a ** b`

Warto zauważyć, że operacje na liczbach zmiennoprzecinkowych mogą prowadzić do niedokładności ze względu na ich reprezentację binarną:

0.1 + 0.2 == 0.3 # False

Aby porównywać liczby zmiennoprzecinkowe, często używa się małego marginesu błędu (epsilon):

import math

math.isclose(0.1 + 0.2, 0.3) # True

Funkcje wbudowane dla typu float:

* `round(x, n)` - zaokrągla liczbę x do n miejsc po przecinku

* `math.floor(x)` - zwraca największą liczbę całkowitą mniejszą lub równą x

* `math.ceil(x)` - zwraca najmniejszą liczbę całkowitą większą lub równą x

3. str (String) - Ciągi znaków

Typ str reprezentuje sekwencje znaków. W Pythonie ciągi znaków są niezmienne (immutable), co oznacza, że nie można modyfikować istniejącego ciągu znaków, ale można tworzyć nowe.

Przykłady deklaracji zmiennych typu str:

a = "Hello, World!"

b = 'Python'

c = """Wieloliniowy

ciąg znaków"""

Operacje na ciągach znaków:

* Konkatenacja (łączenie): `a + b`

* Powtarzanie: `a * 3`

* Indeksowanie: `a` (zwraca pierwszy znak)

* Wycinanie (slicing): `a` (zwraca fragment ciągu od indeksu 1 do 4)

Metody dla typu str:

* `upper()` - zamienia wszystkie litery na wielkie

* `lower()` - zamienia wszystkie litery na małe

* `strip()` - usuwa białe znaki z początku i końca ciągu

* `replace(old, new)` - zamienia wszystkie wystąpienia 'old' na 'new'

* `split()` - dzieli ciąg na listę podciągów

Formatowanie ciągów znaków:

name = "Alice"

age = 30

print(f"{name} is {age} years old") # f-string

print("{} is {} years old".format(name, age)) # metoda format()

4. bool (Boolean) - Wartości logiczne

Typ bool reprezentuje wartości logiczne: True (prawda) lub False (fałsz). Jest często używany w instrukcjach warunkowych i pętlach.

Przykłady deklaracji zmiennych typu bool:

a = True

b = False

Operacje logiczne:

* AND: `a and b`

* OR: `a or b`

* NOT: `not a`

Porównania:

* Równość: `==`

* Nierówność: `!=`

* Większe niż: `>`

* Mniejsze niż: `<`

* Większe lub równe: `>=`

* Mniejsze lub równe: `<=`

Warto zauważyć, że Python traktuje niektóre wartości jako "fałszywe" (falsy) w kontekście logicznym:

* False

* None

* 0

* 0.0

* '' (pusty string)

* \ (pusta lista)

* {} (pusty słownik)

* set() (pusty zbiór)

Wszystkie inne wartości są traktowane jako "prawdziwe" (truthy).

Konwersje między typami:

Python pozwala na konwersję między różnymi typami danych:

* `int(x)` - konwertuje x na liczbę całkowitą

* `float(x)` - konwertuje x na liczbę zmiennoprzecinkową

* `str(x)` - konwertuje x na ciąg znaków

* `bool(x)` - konwertuje x na wartość logiczną

Przykłady:

int("123") # 123

float("3.14") # 3.14

str(42) # "42"

bool(1) # True

bool(0) # False

Znajomość podstawowych typów danych w Pythonie jest kluczowa dla efektywnego programowania, szczególnie w kontekście uczenia maszynowego, gdzie często pracujemy z dużymi ilościami danych różnego typu. Umiejętność manipulowania tymi typami danych pozwala na efektywne przetwarzanie i analizę danych, co jest fundamentem w projektach związanych z uczeniem maszynowym.

Listy i krotki

Listy i krotki są podstawowymi strukturami danych w Pythonie, które służą do przechowywania kolekcji elementów. Obie struktury są szeroko stosowane w uczeniu maszynowym do reprezentacji i manipulacji danymi.

Listy

Listy są mutowalnymi (modyfikowalnymi) sekwencjami, które mogą przechowywać elementy różnych typów.

Tworzenie list:

numbers =

mixed =

empty =

Główne cechy list:

1. Mutowalność: Można modyfikować, dodawać i usuwać elementy.

2. Zachowanie kolejności: Elementy zachowują kolejność, w jakiej zostały dodane.

3. Indeksowanie: Dostęp do elementów przez indeksy (od 0).

4. Dopuszczają duplikaty: Mogą zawierać powtarzające się elementy.

Typowe operacje na listach:

1. Dodawanie elementów:

numbers.append(6) # Dodaje na koniec

numbers.insert(0, 0) # Wstawia 0 na pozycję 0

2. Usuwanie elementów:

numbers.remove(3) # Usuwa pierwsze wystąpienie 3

popped = numbers.pop() # Usuwa i zwraca ostatni element

del numbers # Usuwa element o indeksie 0

3. Indeksowanie i wycinanie:

first = numbers

last_three = numbers

every_second = numbers

4. Łączenie list:

combined = numbers +

5. Sortowanie:

numbers.sort() # Sortuje in-place

sorted_numbers = sorted(numbers) # Zwraca nową posortowaną listę

6. Odwracanie:

numbers.reverse() # Odwraca in-place

reversed_numbers = numbers # Tworzy nową odwróconą listę

Krotki

Krotki są niemutowalnymi (niemodyfikowalnymi) sekwencjami, które również mogą przechowywać elementy różnych typów.

Tworzenie krotek:

coordinates = (10, 20)

single_element = (42,) # Przecinek jest konieczny dla krotki jednoelementowej

empty = ()

Główne cechy krotek:

1. Niemutowalność: Po utworzeniu nie można modyfikować elementów.

2. Zachowanie kolejności: Podobnie jak listy, zachowują kolejność elementów.

3. Indeksowanie: Dostęp do elementów przez indeksy (od 0).

4. Dopuszczają duplikaty: Mogą zawierać powtarzające się elementy.

Typowe operacje na krotkach:

1. Indeksowanie i wycinanie:

x = coordinates

subset = coordinates

2. Łączenie krotek:

combined = coordinates + (30, 40)

3. Rozpakowanie:

x, y = coordinates

Różnice między listami a krotkami:

1. Mutowalność: Listy są mutowalne, krotki nie.

2. Składnia: Listy używają nawiasów kwadratowych \, krotki nawiasów okrągłych ().

3. Wydajność: Krotki są nieco bardziej wydajne w operacjach odczytu.

4. Zastosowanie: Listy są używane dla kolekcji homogenicznych, krotki dla heterogenicznych.

Zastosowania w uczeniu maszynowym:

1. Listy:

* Przechowywanie zestawów cech dla pojedynczych próbek danych.

* Reprezentacja sekwencji danych, np. szeregów czasowych.

* Przechowywanie wyników predykcji modelu.

* Implementacja mini-batchy w treningu sieci neuronowych.

Przykład:

features =

predictions = model.predict(X_test).tolist()

2. Krotki:

* Reprezentacja pojedynczych punktów danych z wieloma cechami.

* Definiowanie stałych parametrów modelu.

* Zwracanie wielu wartości z funkcji.

Przykład:

data_point = (1.75, 70, 30) # (wzrost, waga, wiek)

model_params = (learning_rate, num_epochs, batch_size)

Wybór między listami a krotkami:

* Użyj list, gdy planujesz modyfikować kolekcję (np. dodawać lub usuwać elementy podczas przetwarzania danych).

* Użyj krotek, gdy chcesz zapewnić niezmienność danych (np. dla stałych parametrów modelu).

W praktyce uczenia maszynowego, często wykorzystujemy obie struktury:

# Lista krotek reprezentująca zestaw danych

dataset =

# Przetwarzanie danych

processed_data =

for height, weight, age in dataset:

bmi = weight / (height ** 2)

processed_data.append((height, weight, age, bmi))

# Krotka z parametrami modelu

model_config = (0.01, 100, 32) # (learning_rate, epochs, batch_size)

# Trenowanie modelu

model = train_model(processed_data, *model_config)

Zrozumienie i efektywne wykorzystanie list i krotek jest kluczowe w projektach uczenia maszynowego, gdzie często musimy zarządzać dużymi ilościami danych i parametrów modeli.

Słowniki i zbiory

Słowniki i zbiory to kolejne ważne struktury danych w Pythonie, które są szczególnie przydatne w kontekście uczenia maszynowego ze względu na ich wydajność i elastyczność.

Słowniki (dict)

Słowniki to struktury danych przechowujące pary klucz-wartość. Są one wysoce zoptymalizowane pod kątem szybkiego dostępu do danych.

Tworzenie słowników:

person = {"name": "Alice", "age": 30, "city": "New York"}

empty_dict = {}

dict_from_tuples = dict()

Kluczowe właściwości słowników:

1. Klucze muszą być unikalne i niemutowalne (np. stringi, liczby, krotki).

2. Wartości mogą być dowolnego typu.

3. Słowniki są mutowalne - można dodawać, usuwać i modyfikować elementy.

4. Nie zachowują kolejności (w Pythonie 3.7+ zachowują kolejność dodawania, ale nie należy na tym polegać).

Typowe operacje na słownikach:

1. Dodawanie/modyfikacja elementów:

person = "Engineer"

person = 31

2. Dostęp do elementów:

name = person

age = person.get("age", 0) # Bezpieczny dostęp z wartością domyślną

3. Usuwanie elementów:

del person

job = person.pop("job")

4. Sprawdzanie obecności klucza:

if "name" in person:

print(person)

5. Iteracja:

for key in person:

print(key, person)

for key, value in person.items():

print(key, value)

Zastosowania słowników w uczeniu maszynowym:

1. Przechowywanie metadanych o próbkach danych:

sample = {

"features": ,

"label": "healthy",

"timestamp": "2023-07-03 10:30:00"

}

2. Konfiguracja hiperparametrów modelu:

model_params = {

"learning_rate": 0.01,

"num_epochs": 100,

"batch_size": 32,

"activation": "relu"

}

3. Zliczanie wystąpień (np. w przetwarzaniu tekstu):

word_counts = {}

for word in text.split():

word_counts = word_counts.get(word, 0) + 1

4. Mapowanie kategorii na liczby:

category_mapping = {"cat": 0, "dog": 1, "fish": 2}

Zbiory (set)

Zbiory to kolekcje unikalnych, niemutowalnych elementów. Są one zoptymalizowane pod kątem szybkiego sprawdzania przynależności elementu.

Tworzenie zbiorów:

fruits = {"apple", "banana", "cherry"}

empty_set = set()

set_from_list = set() # {1, 2, 3}

Kluczowe właściwości zbiorów:

1. Elementy muszą być niemutowalne (np. liczby, stringi, krotki).

2. Elementy są unikalne - duplikaty są automatycznie usuwane.

3. Zbiory są mutowalne - można dodawać i usuwać elementy.

4. Nie zachowują kolejności.

Typowe operacje na zbiorach:

1. Dodawanie elementów:

fruits.add("orange")

fruits.update()

2. Usuwanie elementów:

fruits.remove("banana") # Wyrzuca wyjątek, jeśli element nie istnieje

fruits.discard("kiwi") # Nie wyrzuca wyjątku, jeśli element nie istnieje

3. Sprawdzanie przynależności:

if "apple" in fruits:

print("Apple is in the set")

4. Operacje na zbiorach:

set1 = {1, 2, 3}

set2 = {3, 4, 5}

union = set1 | set2 # Suma zbiorów

intersection = set1 & set2 # Część wspólna

difference = set1 - set2 # Różnica zbiorów

Zastosowania zbiorów w uczeniu maszynowym:

1. Usuwanie duplikatów z danych:

unique_categories = set(all_categories)

2. Szybkie sprawdzanie przynależności do kategorii:

valid_categories = {"cat", "dog", "fish"}

if prediction in valid_categories:

print("Valid prediction")

3. Znajdowanie unikalnych cech:

unique_features = set(feature for sample in dataset for feature in sample)

4. Implementacja one-hot encodingu:

categories = {"cat", "dog", "fish"}

one_hot = {category: 1 if category == "dog" else 0 for category in categories}

5. Analiza podobieństwa zbiorów cech:

features1 = {"age", "height", "weight"}

features2 = {"age", "income", "education"}

common_features = features1 & features2

Przykład łączący słowniki i zbiory w uczeniu maszynowym:

# Przygotowanie danych

dataset = , "category": "adult"},

{"features": , "category": "adult"},

{"features": , "category": "child"}

]

# Znalezienie unikalnych kategorii

categories = set(sample for sample in dataset)

# Utworzenie mapowania kategorii na liczby

category_mapping = {category: i for i, category in enumerate(categories)}

# Konwersja kategorii na liczby

for sample in dataset:

sample = category_mapping]

# Przygotowanie danych do treningu

X = for sample in dataset]

y = for sample in dataset]

print("Zbiór kategorii:", categories)

print("Mapowanie kategorii:", category_mapping)

print("Dane do treningu (X):", X)

print("Etykiety (y):", y)

Słowniki i zbiory są niezbędnymi narzędziami w przetwarzaniu danych i implementacji algorytmów uczenia maszynowego. Ich efektywne wykorzystanie może znacząco poprawić wydajność i czytelność kodu w projektach związanych z analizą danych i uczeniem maszynowym.

Tablice NumPy

NumPy (Numerical Python) to fundamentalna biblioteka do obliczeń numerycznych w Pythonie, a jej głównym elementem są tablice (arrays). Tablice NumPy są kluczowe dla uczenia maszynowego ze względu na ich wydajność i funkcjonalność.

Dlaczego tablice NumPy są istotne w uczeniu maszynowym:

1. Wydajność: Operacje na tablicach NumPy są znacznie szybsze niż na standardowych listach Pythona, co jest kluczowe przy pracy z dużymi zbiorami danych.

2. Oszczędność pamięci: Tablice NumPy zajmują mniej pamięci niż listy Pythona, co pozwala na efektywną pracę z większymi zbiorami danych.

3. Wektoryzacja: NumPy umożliwia wykonywanie operacji na całych tablicach bez potrzeby używania pętli, co przyspiesza obliczenia.

4. Integracja: Większość bibliotek do uczenia maszynowego (np. scikit-learn, TensorFlow, PyTorch) korzysta z tablic NumPy jako podstawowego formatu danych.

Tworzenie tablic NumPy:

import numpy as np

# Z listy

arr1 = np.array()

# Z zakresu

arr2 = np.arange(0, 10, 2) #

# Tablica zer lub jedynek

zeros = np.zeros((3, 3))

ones = np.ones((2, 4))

# Tablica losowa

random_arr = np.random.rand(2, 2)

Główne cechy tablic NumPy:

1. Homogeniczność: Wszystkie elementy tablicy muszą być tego samego typu.

2. Wymiarowość: Tablice mogą być jednowymiarowe (wektory), dwuwymiarowe (macierze) lub wielowymiarowe (tensory).

3. Kształt (shape): Określa wymiary tablicy.

4. Dtype: Określa typ danych w tablicy (np. int32, float64).

Podstawowe operacje na tablicach NumPy:

1. Indeksowanie i wycinanie:

arr = np.array(, , ])

print(arr) # 2

print(arr) # , ]

2. Zmiana kształtu:

arr = np.arange(12)

reshaped = arr.reshape(3, 4)

3. Operacje matematyczne:

a = np.array()

b = np.array()

print(a + b) #

print(a * 2) #

print(np.dot(a, b)) # 32

4. Agregacja:

arr = np.array(, ])

print(np.sum(arr)) # 21

print(np.mean(arr)) # 3.5

print(np.max(arr, axis=0)) #

5. Porównania:

arr = np.array()

print(arr > 2) #

print(np.where(arr > 2)) # (array(),)

6. Transpozycja:

arr = np.array(, ])

print(arr.T) # , , ]

Zastosowania tablic NumPy w uczeniu maszynowym:

1. Reprezentacja danych wejściowych:

X = np.array(, ]) # Cechy

y = np.array() # Etykiety

2. Operacje na macierzach w algorytmach ML:

weights = np.random.rand(3, 1)

predictions = np.dot(X, weights)

3. Normalizacja danych:

normalized_X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)

4. One-hot encoding:

categories = np.array()

one_hot = np.eye(3)

5. Obliczanie metryk:

y_true = np.array()

y_pred = np.array()

accuracy = np.mean(y_true == y_pred)

6. Manipulacja obrazami:

image = np.random.rand(100, 100, 3) # RGB image

grayscale = np.mean(image, axis=2)

7. Operacje na mini-batches:

batch_size = 32

num_samples = X.shape

indices = np.random.permutation(num_samples)

for start_idx in range(0, num_samples, batch_size):

batch_indices = indices

X_batch = X

y_batch = y

Przykład użycia tablic NumPy w prostym modelu regresji liniowej:

import numpy as np

# Generowanie danych

X = np.random.rand(100, 1)

y = 2 * X + 1 + np.random.randn(100, 1) * 0.1

# Inicjalizacja parametrów

weights = np.random.randn(1, 1)

bias = np.zeros((1, 1))

# Trening

learning_rate = 0.1

for _ in range(1000):

# Predykcja

y_pred = np.dot(X, weights) + bias

# Obliczenie gradientów

dw = np.dot(X.T, (y_pred - y)) / len(y)

db = np.sum(y_pred - y) / len(y)

# Aktualizacja parametrów

weights -= learning_rate * dw

bias -= learning_rate * db

print("Wagi:", weights.flatten())

print("Bias:", bias.flatten())

Tablice NumPy stanowią fundament dla wielu operacji w uczeniu maszynowym, od przygotowania danych po implementację algorytmów. Ich efektywne wykorzystanie jest kluczowe dla tworzenia wydajnych i skalowalnych rozwiązań w dziedzinie analizy danych i uczenia maszynowego.

2.3. Funkcje i klasy

2.3. Funkcje i klasy

Definiowanie i wywoływanie funkcji w Pythonie

Funkcje są fundamentalnym elementem programowania w Pythonie, umożliwiającym organizację kodu w logiczne, wielokrotnie używane bloki. W kontekście uczenia maszynowego, funkcje są kluczowe dla implementacji algorytmów, przetwarzania danych i organizacji kodu.

Definiowanie funkcji:

Funkcję w Pythonie definiujemy za pomocą słowa kluczowego "def", po którym następuje nazwa funkcji i nawiasy zawierające ewentualne parametry. Ciało funkcji jest wcięte i może zawierać dowolną liczbę instrukcji.

Przykład prostej funkcji:

def greet(name):

return f"Hello, {name}!"

Wywołanie funkcji:

Funkcję wywołujemy, używając jej nazwy i podając odpowiednie argumenty w nawiasach:

message = greet("Alice")

print(message) # Wypisze: Hello, Alice!

Argumenty pozycyjne:

Argumenty pozycyjne są przekazywane do funkcji w kolejności, w jakiej zostały zdefiniowane. Ich liczba i kolejność muszą odpowiadać definicji funkcji.

def add(a, b):

return a + b

result = add(3, 5)

print(result) # Wypisze: 8

Argumenty nazwane:

Argumenty nazwane pozwalają na przekazywanie wartości do funkcji, używając nazw parametrów. Dzięki temu kolejność argumentów nie ma znaczenia.

def describe_person(name, age, city):

return f"{name} is {age} years old and lives in {city}."

description = describe_person(age=30, city="New York", name="Bob")

print(description) # Wypisze: Bob is 30 years old and lives in New York.

Domyślne wartości argumentów:

Możemy przypisać domyślne wartości do argumentów funkcji. Jeśli argument nie zostanie przekazany podczas wywołania funkcji, użyta zostanie wartość domyślna.

def greet(name, greeting="Hello"):

return f"{greeting}, {name}!"

print(greet("Alice")) # Wypisze: Hello, Alice!

print(greet("Bob", "Hi")) # Wypisze: Hi, Bob!

\*args:

Parametr \*args pozwala funkcji przyjmować dowolną liczbę argumentów pozycyjnych. Wewnątrz funkcji args jest krotką zawierającą wszystkie przekazane argumenty.

def sum_all(*args):

return sum(args)

print(sum_all(1, 2, 3)) # Wypisze: 6

print(sum_all(1, 2, 3, 4, 5)) # Wypisze: 15

\*\*kwargs:

Parametr \*\*kwargs pozwala funkcji przyjmować dowolną liczbę argumentów nazwanych. Wewnątrz funkcji kwargs jest słownikiem zawierającym nazwy argumentów jako klucze i ich wartości.

def print_info(**kwargs):

for key, value in kwargs.items():

print(f"{key}: {value}")

print_info(name="Alice", age=30, city="New York")

# Wypisze:

# name: Alice

# age: 30

# city: New York

Łączenie różnych typów argumentów:

Możemy łączyć różne typy argumentów w jednej funkcji. Kolejność definiowania parametrów jest istotna: najpierw argumenty pozycyjne, potem argumenty z wartościami domyślnymi, następnie \*args, i na końcu \*\*kwargs.

def complex_function(a, b, c=10, *args, **kwargs):

print(f"a: {a}")

print(f"b: {b}")

print(f"c: {c}")

print(f"args: {args}")

print(f"kwargs: {kwargs}")

complex_function(1, 2, 3, 4, 5, x=6, y=7)

# Wypisze:

# a: 1

# b: 2

# c: 3

# args: (4, 5)

# kwargs: {'x': 6, 'y': 7}

Funkcje jako obiekty pierwszej klasy:

W Pythonie funkcje są obiektami pierwszej klasy, co oznacza, że można je przypisywać do zmiennych, przekazywać jako argumenty do innych funkcji i zwracać jako wyniki z funkcji.

def apply_operation(func, a, b):

return func(a, b)

def add(x, y):

return x + y

def multiply(x, y):

return x * y

print(apply_operation(add, 3, 4)) # Wypisze: 7

print(apply_operation(multiply, 3, 4)) # Wypisze: 12

Zasięg zmiennych w funkcjach:

Zmienne zdefiniowane wewnątrz funkcji mają zasięg lokalny, co oznacza, że są dostępne tylko wewnątrz tej funkcji. Aby użyć zmiennej globalnej wewnątrz funkcji, należy użyć słowa kluczowego "global".

x = 10

def change_global():

global x

x = 20

print(x) # Wypisze: 10

change_global()

print(x) # Wypisze: 20

Adnotacje typów:

Python 3 wprowadził możliwość dodawania adnotacji typów do funkcji. Choć Python pozostaje językiem dynamicznie typowanym, adnotacje mogą poprawić czytelność kodu i ułatwić debugowanie.

def greet(name: str) -> str:

return f"Hello, {name}!"

print(greet("Alice")) # Wypisze: Hello, Alice!

Funkcje w kontekście uczenia maszynowego:

W projektach uczenia maszynowego funkcje są często używane do:

1. Przetwarzania danych:

def normalize_features(X):

return (X - X.mean(axis=0)) / X.std(axis=0)

2. Implementacji algorytmów:

def gradient_descent(X, y, learning_rate, num_iterations):

m, n = X.shape

theta = np.zeros(n)

for _ in range(num_iterations):

h = np.dot(X, theta)

gradient = np.dot(X.T, (h - y)) / m

theta -= learning_rate * gradient

return theta

3. Obliczania metryk:

def accuracy(y_true, y_pred):

return np.mean(y_true == y_pred)

4. Wizualizacji wyników:

def plot_decision_boundary(X, y, model):

x_min, x_max = X.min() - 0.5, X.max() + 0.5

y_min, y_max = X.min() - 0.5, X.max() + 0.5

xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),

np.arange(y_min, y_max, 0.02))

Z = model.predict(np.c_)

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.4)

plt.scatter(X, X, c=y, alpha=0.8)

plt.xlabel("Feature 1")

plt.ylabel("Feature 2")

plt.title("Decision Boundary")

plt.show()

Zakres zmiennych i przestrzenie nazw

W Pythonie zakres zmiennych i przestrzenie nazw są kluczowymi koncepcjami, które określają dostępność i widoczność zmiennych w różnych częściach programu. Zrozumienie tych koncepcji jest niezbędne do efektywnego pisania funkcji i unikania błędów związanych z niewłaściwym użyciem zmiennych.

Przestrzenie nazw:

Przestrzeń nazw to zbiór nazw (identyfikatorów) i ich odpowiadających obiektów. W Pythonie istnieją różne typy przestrzeni nazw:

1. Wbudowana przestrzeń nazw: Zawiera wbudowane funkcje i typy (np. print(), list(), dict()).

2. Globalna przestrzeń nazw: Obejmuje zmienne zdefiniowane na najwyższym poziomie modułu.

3. Lokalna przestrzeń nazw: Tworzona dla każdego wywołania funkcji i zawiera jej lokalne zmienne.

Zakres zmiennych:

Zakres zmiennej określa, gdzie w kodzie zmienna jest dostępna. Python używa reguły LEGB do wyszukiwania zmiennych: