Uczenie maszynowe w Pythonie - szybki przewodnik
Żyjemy w „erze danych”, która jest wzbogacona o lepszą moc obliczeniową i większe zasoby pamięci masowej. Te dane lub informacje rosną z dnia na dzień, ale prawdziwym wyzwaniem jest nadanie sensu wszystkim danym. Firmy i organizacje próbują sobie z tym poradzić, budując inteligentne systemy, wykorzystując koncepcje i metodologie z nauki o danych, eksploracji danych i uczenia maszynowego. Wśród nich uczenie maszynowe to najbardziej ekscytująca dziedzina informatyki. Nie byłoby źle, gdybyśmy nazywali uczenie maszynowe zastosowaniem i nauką o algorytmach, które zapewniają sens danym.
Co to jest uczenie maszynowe?
Uczenie maszynowe (ML) to dziedzina informatyki, za pomocą której systemy komputerowe mogą nadawać sens danym w podobny sposób, jak robią to ludzie.
Mówiąc prościej, ML to rodzaj sztucznej inteligencji, która wyodrębnia wzorce z surowych danych za pomocą algorytmu lub metody. Głównym celem ML jest umożliwienie systemom komputerowym uczenia się na podstawie doświadczenia bez konieczności bezpośredniego programowania lub interwencji człowieka.
Potrzeba uczenia maszynowego
W tej chwili ludzie są najbardziej inteligentnymi i zaawansowanymi gatunkami na Ziemi, ponieważ potrafią myśleć, oceniać i rozwiązywać złożone problemy. Z drugiej strony sztuczna inteligencja jest wciąż na początkowym etapie i pod wieloma względami nie przewyższyła ludzkiej inteligencji. W takim razie pytanie brzmi, jaka jest potrzeba, aby maszyna się uczyła? Najbardziej odpowiednim powodem takiego działania jest „podejmowanie decyzji na podstawie danych, efektywnie i na skalę”.
Ostatnio organizacje intensywnie inwestują w nowsze technologie, takie jak sztuczna inteligencja, uczenie maszynowe i uczenie głębokie, aby uzyskać kluczowe informacje z danych, aby wykonać kilka rzeczywistych zadań i rozwiązać problemy. Możemy to nazwać decyzjami opartymi na danych, podejmowanymi przez maszyny, szczególnie w celu zautomatyzowania procesu. Te decyzje oparte na danych mogą być stosowane zamiast logiki programowania w przypadku problemów, których nie można zaprogramować z natury. Faktem jest, że nie możemy obejść się bez ludzkiej inteligencji, ale inny aspekt jest taki, że wszyscy musimy rozwiązywać rzeczywiste problemy z wydajnością na ogromną skalę. Dlatego pojawia się potrzeba uczenia maszynowego.
Dlaczego i kiedy uczynić maszyny?
Omówiliśmy już potrzebę uczenia maszynowego, ale pojawia się inne pytanie, w jakich scenariuszach musimy sprawić, by maszyna się uczyła? Może zaistnieć kilka okoliczności, w których potrzebujemy maszyn, aby efektywnie i na ogromną skalę podejmować decyzje oparte na danych. Poniżej przedstawiono niektóre z takich okoliczności, w których uczenie się maszyn byłoby bardziej efektywne -
Brak ludzkiej wiedzy
Pierwszy scenariusz, w którym chcemy, aby maszyna uczyła się i podejmowała decyzje oparte na danych, może być domeną, w której brakuje ludzkiej wiedzy. Przykładami mogą być nawigacje po nieznanych terytoriach lub planetach przestrzennych.
Dynamiczne scenariusze
Istnieje kilka scenariuszy, które mają charakter dynamiczny, tj. Zmieniają się w czasie. W przypadku takich scenariuszy i zachowań chcemy, aby maszyna uczyła się i podejmowała decyzje oparte na danych. Niektóre z przykładów mogą obejmować łączność sieciową i dostępność infrastruktury w organizacji.
Trudność w przełożeniu wiedzy specjalistycznej na zadania obliczeniowe
Mogą istnieć różne dziedziny, w których ludzie mają swoją wiedzę; jednak nie są w stanie przełożyć tej wiedzy na zadania obliczeniowe. W takich okolicznościach chcemy uczenia maszynowego. Przykładami mogą być domeny rozpoznawania mowy, zadań poznawczych itp.
Model uczenia maszynowego
Przed omówieniem modelu uczenia maszynowego musimy zrozumieć następującą formalną definicję ML podaną przez profesora Mitchella:
„Mówi się, że program komputerowy uczy się z doświadczenia E w odniesieniu do pewnej klasy zadań T i miary wydajności P, jeśli jego wydajność w zadaniach w T, mierzona przez P, poprawia się wraz z doświadczeniem E.”
Powyższa definicja koncentruje się w zasadzie na trzech parametrach, również głównych komponentach dowolnego algorytmu uczenia się, a mianowicie zadaniu (T), wydajności (P) i doświadczeniu (E). W tym kontekście możemy uprościć tę definicję, ponieważ -
ML to dziedzina sztucznej inteligencji polegająca na uczeniu się algorytmów, które -
Popraw ich wydajność (P)
Podczas wykonywania jakiegoś zadania (T)
Z biegiem czasu z doświadczeniem (E)
Na podstawie powyższego poniższy diagram przedstawia model uczenia maszynowego -
Omówmy je teraz bardziej szczegółowo -
Zadanie (T)
Z perspektywy problemu możemy zdefiniować zadanie T jako rzeczywisty problem do rozwiązania. Problemem może być znalezienie najlepszej ceny domu w określonej lokalizacji lub znalezienie najlepszej strategii marketingowej itp. Z drugiej strony, jeśli mówimy o uczeniu maszynowym, definicja zadania jest inna, ponieważ trudno jest rozwiązać zadania oparte na ML konwencjonalne podejście do programowania.
Mówi się, że zadanie T jest zadaniem opartym na ML, gdy jest oparte na procesie i system musi przestrzegać, aby operować na punktach danych. Przykłady zadań opartych na ML to klasyfikacja, regresja, ustrukturyzowane adnotacje, grupowanie, transkrypcja itp.
Doświadczenie (E)
Jak sama nazwa wskazuje, jest to wiedza uzyskana z punktów danych dostarczonych do algorytmu lub modelu. Po dostarczeniu z zestawem danych model będzie działał iteracyjnie i nauczy się pewnego nieodłącznego wzorca. Tak zdobyta wiedza nazywa się doświadczeniem (E). Dokonując analogii z ludzkim uczeniem się, możemy myśleć o tej sytuacji jako o tym, że człowiek uczy się lub uzyskuje pewne doświadczenie z różnych atrybutów, takich jak sytuacja, relacje itp. Uczenie się nadzorowane, nienadzorowane i wzmacniające to sposoby na zdobycie doświadczenia. Doświadczenie zdobyte dzięki naszemu modelowi lub algorytmowi ML posłuży do rozwiązania zadania T.
Wydajność (P)
Algorytm ML ma wykonywać zadania i zdobywać doświadczenie wraz z upływem czasu. Miarą, która mówi, czy algorytm ML działa zgodnie z oczekiwaniami, czy nie, jest jego wydajność (P). P jest w zasadzie miarą ilościową, która mówi, w jaki sposób model wykonuje zadanie, T, korzystając z jego doświadczenia, E.Istnieje wiele wskaźników, które pomagają zrozumieć wydajność ML, takie jak wynik dokładności, wynik F1, macierz pomyłki, precyzja, pamięć , wrażliwość itp.
Wyzwania w uczeniu się maszyn
Chociaż uczenie maszynowe szybko ewoluuje, robiąc znaczące postępy w zakresie cyberbezpieczeństwa i samochodów autonomicznych, ten segment sztucznej inteligencji jako całość wciąż ma przed sobą długą drogę. Powodem tego jest to, że ML nie był w stanie pokonać wielu wyzwań. Wyzwania, przed którymi stoi obecnie ML, to:
Quality of data- Posiadanie dobrej jakości danych dla algorytmów ML jest jednym z największych wyzwań. Korzystanie z danych niskiej jakości prowadzi do problemów związanych z przetwarzaniem wstępnym danych i ekstrakcją cech.
Time-Consuming task - Kolejnym wyzwaniem stojącym przed modelami ML jest czasochłonność, szczególnie na gromadzenie danych, wyodrębnianie cech i odzyskiwanie.
Lack of specialist persons - Ponieważ technologia ML jest wciąż w powijakach, dostępność zasobów eksperckich jest trudna.
No clear objective for formulating business problems - Brak jasnego celu i dobrze zdefiniowanego celu dla problemów biznesowych jest kolejnym kluczowym wyzwaniem dla ML, ponieważ ta technologia nie jest jeszcze tak dojrzała.
Issue of overfitting & underfitting - Jeśli model jest nadmiernie dopasowany lub niedopasowany, nie można go dobrze przedstawić dla problemu.
Curse of dimensionality- Kolejnym wyzwaniem, przed którym stoi model ML, jest zbyt wiele cech punktów danych. To może być prawdziwą przeszkodą.
Difficulty in deployment - Złożoność modelu ML sprawia, że jest on dość trudny do wdrożenia w prawdziwym życiu.
Zastosowania uczenia maszynowego
Uczenie maszynowe to najszybciej rozwijająca się technologia i według naukowców znajdujemy się w złotym roku AI i ML. Służy do rozwiązywania wielu złożonych problemów w świecie rzeczywistym, których nie można rozwiązać tradycyjnym podejściem. Oto kilka rzeczywistych zastosowań ML -
Analiza emocji
Analiza nastrojów
Wykrywanie i zapobieganie błędom
Prognozowanie i przewidywanie pogody
Analiza i prognozy giełdowe
Synteza mowy
Rozpoznawanie mowy
Segmentacja klientów
Rozpoznawanie obiektów
Wykrywanie oszustw
Zapobieganie oszustwom
Rekomendowanie produktów klientowi w zakupach online.
Wprowadzenie do Pythona
Python jest popularnym językiem programowania zorientowanym obiektowo, posiadającym możliwości języka programowania wysokiego poziomu. Łatwa do nauczenia się składnia i możliwość przenoszenia sprawiają, że jest obecnie popularny. Poniższe fakty stanowią wprowadzenie do Pythona -
Python został opracowany przez Guido van Rossuma w Stichting Mathematisch Centrum w Holandii.
Został napisany jako następca języka programowania o nazwie „ABC”.
Jego pierwsza wersja została wydana w 1991 roku.
Nazwa Python została wybrana przez Guido van Rossuma z programu telewizyjnego o nazwie Latający Cyrk Monty Pythona.
Jest to język programowania typu open source, co oznacza, że możemy go swobodnie pobierać i używać do tworzenia programów. Można go pobrać ze strony www.python.org .
Język programowania Python ma zarówno funkcje Java, jak i C. Ma elegancki kod „C”, az drugiej strony ma klasy i obiekty, takie jak Java do programowania obiektowego.
Jest to język interpretowany, co oznacza, że kod źródłowy programu w Pythonie byłby najpierw konwertowany na kod bajtowy, a następnie wykonywany przez maszynę wirtualną Pythona.
Mocne i słabe strony Pythona
Każdy język programowania ma swoje mocne i słabe strony, podobnie jak Python.
Silne strony
Według badań i ankiet Python jest piątym najważniejszym językiem, a także najpopularniejszym językiem do uczenia maszynowego i nauki o danych. Python ma następujące mocne strony -
Easy to learn and understand- Składnia Pythona jest prostsza; stąd też stosunkowo łatwo, nawet dla początkujących, nauczyć się i zrozumieć język.
Multi-purpose language - Python to uniwersalny język programowania, ponieważ obsługuje programowanie strukturalne, programowanie obiektowe, a także programowanie funkcjonalne.
Huge number of modules- Python ma ogromną liczbę modułów do pokrycia każdego aspektu programowania. Te moduły są łatwo dostępne do użycia, dzięki czemu Python jest językiem rozszerzalnym.
Support of open source community- Jako język programowania open source, Python jest obsługiwany przez bardzo dużą społeczność programistów. Z tego powodu błędy są łatwo naprawiane przez społeczność Pythona. Ta cecha sprawia, że Python jest bardzo solidny i adaptacyjny.
Scalability - Python jest skalowalnym językiem programowania, ponieważ zapewnia ulepszoną strukturę do obsługi dużych programów niż skrypty powłoki.
Słabość
Chociaż Python jest popularnym i potężnym językiem programowania, ma swoją słabość polegającą na powolnej szybkości wykonywania.
Szybkość wykonywania Pythona jest wolna w porównaniu z językami kompilowanymi, ponieważ Python jest językiem interpretowanym. Może to być główny obszar ulepszeń dla społeczności Pythona.
Instalowanie Pythona
Aby pracować w Pythonie, musimy go najpierw zainstalować. Możesz przeprowadzić instalację Pythona na jeden z następujących dwóch sposobów -
Instalowanie Pythona indywidualnie
Używanie wstępnie spakowanej dystrybucji Pythona - Anaconda
Omówmy je szczegółowo.
Instalowanie Pythona pojedynczo
Jeśli chcesz zainstalować Pythona na swoim komputerze, musisz pobrać tylko kod binarny odpowiedni dla Twojej platformy. Dystrybucja Pythona jest dostępna na platformy Windows, Linux i Mac.
Poniżej znajduje się krótkie omówienie instalacji Pythona na wyżej wymienionych platformach -
On Unix and Linux platform
Wykonując następujące kroki, możemy zainstalować Python na platformie Unix i Linux -
Najpierw przejdź do https://www.python.org/downloads/.
Następnie kliknij łącze, aby pobrać spakowany kod źródłowy dostępny dla systemów Unix / Linux.
Teraz pobierz i wyodrębnij pliki.
Następnie możemy edytować plik Modules / Setup, jeśli chcemy dostosować niektóre opcje.
Następnie napisz polecenie run ./configure script
make
dokonać instalacji
On Windows platform
Wykonując następujące kroki, możemy zainstalować Pythona na platformie Windows -
Najpierw przejdź do https://www.python.org/downloads/.
Następnie kliknij łącze do pliku instalatora Windows python-XYZ.msi. Tutaj XYZ to wersja, którą chcemy zainstalować.
Teraz musimy uruchomić pobrany plik. To przeniesie nas do kreatora instalacji Pythona, który jest łatwy w użyciu. Teraz zaakceptuj ustawienia domyślne i poczekaj, aż instalacja się zakończy.
On Macintosh platform
Dla Mac OS X, Homebrew, świetny i łatwy w użyciu instalator pakietów jest zalecany do zainstalowania Pythona 3. W przypadku, gdy nie masz Homebrew, możesz go zainstalować za pomocą następującego polecenia -
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"Można go zaktualizować za pomocą poniższego polecenia -
$ brew updateTeraz, aby zainstalować Python3 w twoim systemie, musimy uruchomić następujące polecenie -
$ brew install python3Używanie wstępnie spakowanej dystrybucji języka Python: Anaconda
Anaconda to spakowana kompilacja Pythona, która zawiera wszystkie biblioteki szeroko używane w nauce o danych. Możemy wykonać następujące kroki, aby skonfigurować środowisko Python za pomocą Anacondy -
Step1- Najpierw musimy pobrać wymagany pakiet instalacyjny z dystrybucji Anaconda. Link do tego samego tohttps://www.anaconda.com/distribution/. Możesz wybrać system operacyjny Windows, Mac i Linux zgodnie z wymaganiami.
Step2- Następnie wybierz wersję Pythona, którą chcesz zainstalować na swoim komputerze. Najnowsza wersja Pythona to 3.7. Tam znajdziesz opcje zarówno dla 64-bitowego, jak i 32-bitowego instalatora graficznego.
Step3- Po wybraniu wersji systemu operacyjnego i Pythona, pobierze instalator Anaconda na twój komputer. Teraz kliknij dwukrotnie plik, a instalator zainstaluje pakiet Anaconda.
Step4 - Aby sprawdzić, czy jest zainstalowany, czy nie, otwórz wiersz polecenia i wpisz Python w następujący sposób -
Możesz to również sprawdzić w szczegółowym wykładzie wideo pod adresemhttps://www.tutorialspoint.com/python_essentials_online_training/getting_started_with_anaconda.asp.
Dlaczego Python do nauki o danych?
Python jest piątym najważniejszym językiem, a także najpopularniejszym językiem do uczenia maszynowego i nauki o danych. Oto cechy Pythona, które sprawiają, że jest to preferowany język do nauki o danych -
Bogaty zestaw pakietów
Python ma obszerny i potężny zestaw pakietów, które są gotowe do użycia w różnych domenach. Posiada również pakiety takie jak numpy, scipy, pandas, scikit-learn itp., Które są wymagane do uczenia maszynowego i nauki o danych.
Łatwe prototypowanie
Inną ważną cechą Pythona, która sprawia, że jest to język do nauki o danych, jest łatwe i szybkie prototypowanie. Ta funkcja jest przydatna przy opracowywaniu nowego algorytmu.
Funkcja współpracy
Dziedzina nauki o danych zasadniczo wymaga dobrej współpracy, a Python zapewnia wiele przydatnych narzędzi, które sprawiają, że jest to wyjątkowo.
Jeden język dla wielu dziedzin
Typowy projekt data science obejmuje różne dziedziny, takie jak ekstrakcja danych, manipulacja danymi, analiza danych, wyodrębnianie cech, modelowanie, ocena, wdrażanie i aktualizacja rozwiązania. Ponieważ Python jest językiem wielofunkcyjnym, umożliwia analitykom danych dotarcie do wszystkich tych domen z poziomu wspólnej platformy.
Komponenty ekosystemu Python ML
W tej sekcji omówimy kilka podstawowych bibliotek Data Science, które tworzą składniki ekosystemu uczenia maszynowego Python. Te przydatne komponenty sprawiają, że Python jest ważnym językiem dla nauki o danych. Chociaż istnieje wiele takich komponentów, omówmy tutaj niektóre z ważnych składników ekosystemu Pythona -
Notatnik Jupyter
Notebooki Jupyter zasadniczo zapewniają interaktywne środowisko obliczeniowe do tworzenia aplikacji do nauki danych opartych na języku Python. Wcześniej były znane jako notatniki ipython. Oto niektóre cechy notebooków Jupyter, które sprawiają, że jest to jeden z najlepszych elementów ekosystemu Python ML -
Notatniki Jupyter mogą zilustrować proces analizy krok po kroku, układając elementy, takie jak kod, obrazy, tekst, dane wyjściowe itp., Krok po kroku.
Pomaga analitykowi danych dokumentować proces myślowy podczas opracowywania procesu analizy.
Wynik można również uchwycić jako część zeszytu.
Za pomocą notatników jupyter możemy również dzielić się naszą pracą z rówieśnikami.
Instalacja i wykonanie
Jeśli używasz dystrybucji Anaconda, nie musisz oddzielnie instalować notebooka jupyter, ponieważ jest już z nim zainstalowany. Wystarczy przejść do polecenia Anaconda i wpisać następujące polecenie -
C:\>jupyter notebookPo naciśnięciu klawisza Enter uruchomi serwer notebooka pod adresem localhost: 8888 twojego komputera. Jest to pokazane na poniższym zrzucie ekranu -
Teraz po kliknięciu zakładki Nowa pojawi się lista opcji. Wybierz Python 3, a zostaniesz przeniesiony do nowego notatnika, aby rozpocząć z nim pracę. Zobaczysz to na poniższych zrzutach ekranu -
Z drugiej strony, jeśli używasz standardowej dystrybucji Pythona, notebook jupyter można zainstalować za pomocą popularnego instalatora pakietów Pythona, pip.
pip install jupyterRodzaje komórek w notatniku Jupyter
Poniżej przedstawiono trzy typy komórek w notebooku jupyter -
Code cells- Jak sama nazwa wskazuje, możemy użyć tych komórek do napisania kodu. Po zapisaniu kodu / treści prześle je do jądra, które jest powiązane z notatnikiem.
Markdown cells- Możemy użyć tych komórek do zapisu procesu obliczeniowego. Mogą zawierać takie rzeczy, jak tekst, obrazy, równania Latex, tagi HTML itp.
Raw cells- Tekst w nich wpisany jest wyświetlany tak, jak jest. Te komórki są w zasadzie używane do dodawania tekstu, którego nie chcemy konwertować przez mechanizm automatycznej konwersji notatnika jupyter.
Aby uzyskać bardziej szczegółowe badanie notatnika jupyter, możesz przejść do linkuhttps://www.tutorialspoint.com/jupyter/index.htm.
NumPy
Jest to kolejny przydatny komponent, dzięki któremu Python jest jednym z ulubionych języków Data Science. Zasadniczo oznacza Numerical Python i składa się z wielowymiarowych obiektów tablicowych. Korzystając z NumPy, możemy wykonać następujące ważne operacje -
Operacje matematyczne i logiczne na tablicach.
Transformacja Fouriera
Działania związane z algebrą liniową.
Widzimy również NumPy jako zamiennik MatLab, ponieważ NumPy jest używany głównie wraz z Scipy (Scientific Python) i Mat-plotlib (biblioteka kreśląca).
Installation and Execution
Jeśli używasz dystrybucji Anaconda, nie musisz oddzielnie instalować NumPy, ponieważ jest już z nią zainstalowany. Wystarczy zaimportować pakiet do skryptu Pythona za pomocą następujących czynności -
import numpy as npZ drugiej strony, jeśli używasz standardowej dystrybucji Pythona, NumPy można zainstalować za pomocą popularnego instalatora pakietów Pythona, pip.
pip install NumPyAby uzyskać bardziej szczegółowe badanie NumPy, możesz przejść do linkuhttps://www.tutorialspoint.com/numpy/index.htm.
Pandy
Jest to kolejna użyteczna biblioteka Pythona, dzięki której Python jest jednym z ulubionych języków nauki o danych. Pandy są zasadniczo używane do manipulacji danymi, sprzeciwiania się i analizy. Został opracowany przez Wesa McKinneya w 2008 roku. Z pomocą Pandy w przetwarzaniu danych możemy wykonać następujące pięć kroków -
Load
Prepare
Manipulate
Model
Analyze
Reprezentacja danych w Pandach
Cała reprezentacja danych w Pandas odbywa się za pomocą następujących trzech struktur danych -
Series- Jest to w zasadzie jednowymiarowa tablica ndarray z etykietą osi, co oznacza, że przypomina prostą tablicę z jednorodnymi danymi. Na przykład poniższa seria to zbiór liczb całkowitych 1,5,10,15,24,25…
| 1 | 5 | 10 | 15 | 24 | 25 | 28 | 36 | 40 | 89 |
Data frame- Jest to najbardziej użyteczna struktura danych i używana do prawie wszystkich rodzajów reprezentacji danych i manipulacji na pandach. Zasadniczo jest to dwuwymiarowa struktura danych, która może zawierać dane heterogeniczne. Ogólnie dane tabelaryczne są reprezentowane za pomocą ramek danych. Na przykład poniższa tabela pokazuje dane uczniów posiadających ich imiona i numery rolek, wiek i płeć -
Nazwa |
Numer rolki |
Wiek |
Płeć |
|---|---|---|---|
Aarav |
1 |
15 |
Męski |
Ostre |
2 |
14 |
Męski |
Kanika |
3 |
16 |
Płeć żeńska |
Mayank |
4 |
15 |
Męski |
Panel- Jest to trójwymiarowa struktura danych zawierająca dane heterogeniczne. Przedstawienie panelu w formie graficznej jest bardzo trudne, ale można go zilustrować jako kontener DataFrame.
Poniższa tabela przedstawia wymiary i opis wyżej wymienionych struktur danych używanych w Pandach -
Struktura danych |
Wymiar |
Opis |
|---|---|---|
Seria |
1-D |
Niezmienne wielkości, jednorodne dane 1-D |
DataFrames |
2-D |
Zmienne wielkości, heterogeniczne dane w formie tabelarycznej |
Płyta |
3-D |
Tablica z możliwością zmiany rozmiaru, kontener DataFrame. |
Możemy zrozumieć te struktury danych, ponieważ struktura danych o wyższych wymiarach jest pojemnikiem struktury danych o niższych wymiarach.
Instalacja i wykonanie
Jeśli używasz dystrybucji Anaconda, nie musisz instalować osobno Pandy, ponieważ jest już z nią zainstalowana. Wystarczy zaimportować pakiet do skryptu Pythona za pomocą następujących czynności -
import pandas as pdZ drugiej strony, jeśli używasz standardowej dystrybucji Pythona, Pandy można zainstalować za pomocą popularnego instalatora pakietów Pythona, pip.
pip install PandasPo zainstalowaniu Pandy możesz zaimportować go do swojego skryptu Python, tak jak powyżej.
Przykład
Poniżej znajduje się przykład tworzenia serii z ndarray przy użyciu Pandy -
In [1]: import pandas as pd
In [2]: import numpy as np
In [3]: data = np.array(['g','a','u','r','a','v'])
In [4]: s = pd.Series(data)
In [5]: print (s)
0 g
1 a
2 u
3 r
4 a
5 v
dtype: objectAby uzyskać bardziej szczegółowe badanie Pand, możesz przejść do linku https://www.tutorialspoint.com/python_pandas/index.htm.
Scikit-learn
Inną przydatną i najważniejszą biblioteką Pythona do nauki o danych i uczenia maszynowego w Pythonie jest Scikit-learn. Oto niektóre funkcje Scikit-Learn, które sprawiają, że jest tak przydatny -
Jest zbudowany na NumPy, SciPy i Matplotlib.
Jest to oprogramowanie typu open source i może być ponownie użyte na licencji BSD.
Jest dostępny dla każdego i można go ponownie wykorzystać w różnych kontekstach.
Za jego pomocą można zaimplementować szeroką gamę algorytmów uczenia maszynowego obejmujących główne obszary ML, takie jak klasyfikacja, grupowanie, regresja, redukcja wymiarowości, wybór modelu itp.
Instalacja i wykonanie
Jeśli używasz dystrybucji Anaconda, nie musisz oddzielnie instalować Scikit-learn, ponieważ jest już z nią zainstalowany. Wystarczy, że użyjesz pakietu w swoim skrypcie w Pythonie. Na przykład za pomocą następującego wiersza skryptu importujemy zbiór danych pacjentów z rakiem piersi zScikit-learn -
from sklearn.datasets import load_breast_cancerZ drugiej strony, jeśli używasz standardowej dystrybucji Pythona i masz NumPy i SciPy, Scikit-learn można zainstalować za pomocą popularnego instalatora pakietów Pythona, pip.
pip install -U scikit-learnPo zainstalowaniu Scikit-learn możesz użyć go w swoim skrypcie Pythona, tak jak to zrobiłeś powyżej.
Istnieją różne algorytmy, techniki i metody ML, które można wykorzystać do tworzenia modeli rozwiązywania rzeczywistych problemów przy użyciu danych. W tym rozdziale omówimy różne rodzaje metod.
Różne rodzaje metod
Poniżej przedstawiono różne metody ML oparte na niektórych szerokich kategoriach -
Na podstawie nadzoru człowieka
W procesie uczenia się niektóre metody oparte na nadzorze człowieka są następujące:
Supervised Learning
Algorytmy lub metody uczenia nadzorowanego są najczęściej używanymi algorytmami ML. Ta metoda lub algorytm uczenia się pobiera próbkę danych, tj. Dane uczące i powiązane z nimi dane wyjściowe, tj. Etykiety lub odpowiedzi z każdą próbką danych podczas procesu uczenia.
Głównym celem algorytmów uczenia nadzorowanego jest poznanie powiązań między próbkami danych wejściowych a odpowiadającymi im wynikami po wykonaniu wielu instancji danych szkoleniowych.
Na przykład mamy
x: zmienne wejściowe i
Y: zmienna wyjściowa
Teraz zastosuj algorytm, aby nauczyć się funkcji mapowania z wejścia do wyjścia w następujący sposób -
Y = f (x)
Teraz głównym celem byłoby tak dokładne przybliżenie funkcji mapowania, że nawet mając nowe dane wejściowe (x), możemy łatwo przewidzieć zmienną wyjściową (Y) dla tych nowych danych wejściowych.
Nazywa się to nadzorowanym, ponieważ cały proces uczenia się można myśleć tak, jak jest nadzorowany przez nauczyciela lub superwizora. Przykłady nadzorowanych algorytmów uczenia maszynowego obejmująDecision tree, Random Forest, KNN, Logistic Regression itp.
Na podstawie zadań ML, nadzorowane algorytmy uczenia się można podzielić na dwie szerokie klasy -
Classification
Regression
Classification
Głównym celem zadań opartych na klasyfikacji jest przewidywanie kategorialnych etykiet wyjściowych lub odpowiedzi dla danych wejściowych. Wynik będzie oparty na tym, czego model nauczył się w fazie szkolenia. Ponieważ wiemy, że kategorialne odpowiedzi wyjściowe oznaczają nieuporządkowane i dyskretne wartości, stąd każda odpowiedź wyjściowa będzie należeć do określonej klasy lub kategorii. W kolejnych rozdziałach szczegółowo omówimy klasyfikację i powiązane z nią algorytmy.
Regression
Głównym celem zadań opartych na regresji jest przewidywanie etykiet wyjściowych lub odpowiedzi, które są ciągłymi wartościami liczbowymi dla danych wejściowych. Wynik będzie oparty na tym, czego model nauczył się w fazie szkolenia. Zasadniczo modele regresji wykorzystują cechy danych wejściowych (zmienne niezależne) i odpowiadające im ciągłe liczbowe wartości wyjściowe (zmienne zależne lub wynikowe), aby nauczyć się określonego związku między danymi wejściowymi a odpowiadającymi im wynikami. W dalszych rozdziałach omówimy szczegółowo regresję i powiązane z nią algorytmy.
Uczenie się bez nadzoru
Jak sama nazwa wskazuje, jest odwrotnie do nadzorowanych metod lub algorytmów ML, co oznacza, że w algorytmach uczenia maszynowego bez nadzoru nie mamy żadnego nadzorcy, który mógłby udzielać jakichkolwiek wskazówek. Algorytmy uczenia bez nadzoru są przydatne w scenariuszu, w którym nie mamy wolności, jak w przypadku algorytmów uczenia nadzorowanego, posiadania wstępnie oznaczonych danych szkoleniowych i chcemy wydobyć przydatny wzorzec z danych wejściowych.
Na przykład można to rozumieć w następujący sposób -
Załóżmy, że mamy -
x: Input variables, wtedy nie byłoby odpowiedniej zmiennej wyjściowej, a algorytmy musiałyby odkryć interesujący wzorzec w danych do uczenia się.
Przykłady nienadzorowanych algorytmów uczenia maszynowego obejmują grupowanie K-średnich, K-nearest neighbors itp.
Na podstawie zadań ML, nienadzorowane algorytmy uczenia się można podzielić na następujące szerokie klasy -
Clustering
Association
Redukcja wymiarowości
Clustering
Metody klastrowania są jednymi z najbardziej użytecznych nienadzorowanych metod ML. Algorytmy te służyły do znajdowania podobieństw i wzorców relacji między próbkami danych, a następnie grupowania tych próbek w grupy o podobieństwie na podstawie cech. Rzeczywistym przykładem tworzenia klastrów jest grupowanie klientów według ich zachowań zakupowych.
Association
Inną użyteczną metodą ML bez nadzoru jest Associationktóry jest używany do analizy dużego zbioru danych w celu znalezienia wzorców, które dodatkowo reprezentują interesujące relacje między różnymi elementami. Jest również określany jakoAssociation Rule Mining lub Market basket analysis który służy głównie do analizy zachowań zakupowych klientów.
Dimensionality Reduction
Ta nienadzorowana metoda ML służy do zmniejszania liczby zmiennych cech dla każdej próbki danych poprzez wybór zestawu cech głównych lub reprezentatywnych. Powstaje tutaj pytanie, dlaczego musimy zmniejszyć wymiarowość? Przyczyną tego jest problem złożoności przestrzeni cech, który pojawia się, gdy zaczynamy analizować i wyodrębniać miliony cech z próbek danych. Ten problem ogólnie odnosi się do „przekleństwa wymiarowości”. PCA (Principal Component Analysis), K-najbliższych sąsiadów i analiza dyskryminacyjna to tylko niektóre z popularnych algorytmów służących do tego celu.
Anomaly Detection
Ta nienadzorowana metoda ML jest używana do wykrywania rzadkich zdarzeń lub obserwacji, które na ogół nie występują. Wykorzystując zdobytą wiedzę, metody wykrywania anomalii umożliwiłyby rozróżnienie między anomalnym a normalnym punktem danych. Niektóre nienadzorowane algorytmy, takie jak grupowanie, KNN mogą wykrywać anomalie na podstawie danych i ich cech.
Nauka częściowo nadzorowana
Tego rodzaju algorytmy lub metody nie są ani w pełni nadzorowane, ani całkowicie nienadzorowane. Zasadniczo mieszczą się między tymi dwoma, tj. Metodami uczenia się pod nadzorem i bez nadzoru. Tego rodzaju algorytmy generalnie wykorzystują mały nadzorowany komponent uczenia się, tj. Niewielką ilość wstępnie oznaczonych danych z adnotacjami i duży nienadzorowany komponent uczenia się, tj. Wiele nieoznaczonych danych do szkolenia. Możemy zastosować dowolne z następujących podejść do wdrażania częściowo nadzorowanych metod uczenia się -
Pierwszym i prostym podejściem jest zbudowanie nadzorowanego modelu w oparciu o niewielką ilość oznaczonych i opatrzonych adnotacjami danych, a następnie zbudowanie modelu bez nadzoru poprzez zastosowanie tego samego do dużych ilości nieoznakowanych danych, aby uzyskać więcej oznaczonych próbek. Teraz wytrenuj na nich model i powtórz proces.
- , p> Drugie podejście wymaga dodatkowych wysiłków. W tym podejściu możemy najpierw użyć metod nienadzorowanych, aby skupić podobne próbki danych, opisać te grupy, a następnie użyć kombinacji tych informacji do wytrenowania modelu.
Uczenie się ze wzmocnieniem
Metody te różnią się od dotychczas badanych i są również bardzo rzadko stosowane. W tego rodzaju algorytmach uczenia się byłby agent, którego chcielibyśmy wyszkolić przez pewien okres czasu, aby mógł wchodzić w interakcje z określonym środowiskiem. Agent będzie postępował zgodnie z zestawem strategii interakcji z otoczeniem, a następnie po obserwacji otoczenia podejmie działania dotyczące aktualnego stanu środowiska. Poniżej przedstawiono główne etapy metod uczenia się ze wzmocnieniem -
Step1 - Najpierw musimy przygotować agenta z pewnym wstępnym zestawem strategii.
Step2 - Następnie obserwuj otoczenie i jego aktualny stan.
Step3 - Następnie wybierz optymalną politykę względem aktualnego stanu środowiska i wykonaj ważne działania.
Step4 - Teraz agent może otrzymać odpowiednią nagrodę lub karę, zgodnie z działaniem podjętym przez niego w poprzednim kroku.
Step5 - Teraz możemy zaktualizować strategie, jeśli jest to wymagane.
Step6 - Na koniec powtarzaj kroki 2-5, aż agent nauczy się i zastosuje optymalne zasady.
Zadania odpowiednie do uczenia maszynowego
Poniższy diagram pokazuje, jaki typ zadania jest odpowiedni dla różnych problemów ML -
Oparte na zdolności uczenia się
W procesie uczenia się są następujące metody oparte na zdolności uczenia się -
Batch Learning
W wielu przypadkach mamy kompleksowe systemy Machine Learning, w których musimy trenować model za jednym razem, wykorzystując całe dostępne dane szkoleniowe. Taka metoda uczenia się lub algorytm to tzwBatch or Offline learning. Nazywa się to uczeniem wsadowym lub offline, ponieważ jest to procedura jednorazowa, a model będzie szkolony z danymi w jednej partii. Poniżej przedstawiono główne kroki metod uczenia wsadowego -
Step1 - Najpierw musimy zebrać wszystkie dane treningowe, aby rozpocząć trenowanie modelu.
Step2 - Teraz rozpocznij uczenie modelu, dostarczając pełne dane szkoleniowe za jednym razem.
Step3 - Następnie zakończ proces uczenia się / treningu po uzyskaniu zadowalających wyników / osiągnięć.
Step4- Na koniec wdróż wyszkolony model do produkcji. Tutaj będzie przewidywać wynik dla nowej próbki danych.
Nauka online
Jest to zupełnie odwrotne do metod uczenia się w trybie wsadowym lub offline. W tych metodach uczenia dane szkoleniowe są dostarczane do algorytmu w wielu przyrostowych partiach, zwanych minipartiami. Oto główne kroki metod uczenia się online -
Step1 - Najpierw musimy zebrać wszystkie dane treningowe, aby rozpocząć uczenie modelu.
Step2 - Teraz rozpocznij uczenie modelu, dostarczając mini partię danych uczących do algorytmu.
Step3 - Następnie musimy dostarczyć do algorytmu mini-partie danych szkoleniowych w wielu przyrostach.
Step4 - Ponieważ nie zatrzyma się jak uczenie wsadowe, a więc po dostarczeniu całych danych szkoleniowych w minisadach, należy również dostarczyć nowe próbki danych.
Step5 - Wreszcie będzie się uczyć przez pewien czas w oparciu o nowe próbki danych.
Oparte na podejściu uogólniającym
W procesie uczenia się poniżej przedstawiono niektóre metody oparte na podejściu uogólniającym -
Uczenie się oparte na instancjach
Metoda uczenia się oparta na instancjach jest jedną z przydatnych metod służących do budowania modeli ML poprzez generalizację na podstawie danych wejściowych. Jest to przeciwieństwo wcześniej badanych metod uczenia się, ponieważ ten rodzaj uczenia się obejmuje systemy ML, a także metody, które wykorzystują same surowe punkty danych do rysowania wyników dla nowszych próbek danych bez budowania wyraźnego modelu na danych szkoleniowych.
Mówiąc prościej, uczenie się oparte na instancjach zasadniczo zaczyna działać od spojrzenia na punkty danych wejściowych, a następnie przy użyciu miernika podobieństwa uogólni i przewiduje nowe punkty danych.
Uczenie się oparte na modelach
W metodach uczenia się opartych na modelu proces iteracyjny odbywa się na modelach ML, które są zbudowane na podstawie różnych parametrów modelu, zwanych hiperparametrami, w których dane wejściowe są używane do wyodrębniania cech. Podczas tego uczenia hiperparametry są optymalizowane w oparciu o różne techniki walidacji modeli. Dlatego możemy powiedzieć, że metody uczenia się oparte na modelu wykorzystują bardziej tradycyjne podejście ML do generalizacji.
Załóżmy, że jeśli chcesz rozpocząć projekt ML, to jaka jest pierwsza i najważniejsza rzecz, której byś potrzebował? Są to dane, które musimy załadować, aby rozpocząć dowolny projekt ML. Jeśli chodzi o dane, najpopularniejszym formatem danych w projektach ML jest CSV (wartości oddzielone przecinkami).
Zasadniczo CSV to prosty format pliku, który służy do przechowywania danych tabelarycznych (liczb i tekstu), takich jak arkusz kalkulacyjny w postaci zwykłego tekstu. W Pythonie możemy ładować dane CSV na różne sposoby, ale przed załadowaniem danych CSV musimy zadbać o kilka kwestii.
Rozważanie podczas ładowania danych CSV
Format danych CSV jest najpopularniejszym formatem danych ML, ale musimy zadbać o przestrzeganie głównych kwestii podczas ładowania tego samego do naszych projektów ML -
Nagłówek pliku
W plikach danych CSV nagłówek zawiera informacje dla każdego pola. Musimy użyć tego samego separatora dla pliku nagłówkowego i dla pliku danych, ponieważ to plik nagłówkowy określa, w jaki sposób należy interpretować pola danych.
Poniżej znajdują się dwa przypadki związane z nagłówkiem pliku CSV, które należy wziąć pod uwagę -
Case-I: When Data file is having a file header - Automatycznie przypisze nazwy do każdej kolumny danych, jeśli plik danych ma nagłówek pliku.
Case-II: When Data file is not having a file header - Musimy ręcznie przypisać nazwy do każdej kolumny danych, jeśli plik danych nie ma nagłówka pliku.
W obu przypadkach musimy wyraźnie określić, czy nasz plik CSV zawiera nagłówek, czy nie.
Komentarze
Komentarze w dowolnym pliku danych mają swoje znaczenie. W pliku danych CSV komentarze są oznaczone krzyżykiem (#) na początku wiersza. Musimy wziąć pod uwagę komentarze podczas ładowania danych CSV do projektów ML, ponieważ jeśli mamy komentarze w pliku, być może będziemy musieli wskazać, zależy od metody, którą wybierzemy do załadowania, czy oczekiwać tych komentarzy, czy nie.
Separator
W plikach danych CSV przecinek (,) jest standardowym separatorem. Rolą separatora jest oddzielenie wartości w polach. Ważne jest, aby wziąć pod uwagę rolę separatora podczas przesyłania pliku CSV do projektów ML, ponieważ możemy również użyć innego separatora, takiego jak tabulator lub spacja. Ale w przypadku użycia innego separatora niż standardowy, musimy go wyraźnie określić.
cytaty
W plikach danych CSV domyślnym cudzysłowem jest znak podwójnego cudzysłowu („”). Ważne jest, aby wziąć pod uwagę rolę cudzysłowów podczas przesyłania pliku CSV do projektów ML, ponieważ możemy również użyć innego znaku cudzysłowu niż podwójny cudzysłów. Ale w przypadku użycia innego znaku cudzysłowu niż standardowy, musimy to wyraźnie określić.
Metody ładowania pliku danych CSV
Podczas pracy z projektami ML najważniejszym zadaniem jest prawidłowe załadowanie do niego danych. Najpopularniejszym formatem danych w projektach ML jest CSV, który ma różne smaki i różne trudności w analizie. W tej sekcji omówimy trzy typowe podejścia w Pythonie do ładowania pliku danych CSV -
Załaduj plik CSV za pomocą biblioteki standardowej Python
Pierwszym i najczęściej używanym podejściem do załadowania pliku danych CSV jest użycie standardowej biblioteki Python, która zapewnia nam różnorodne wbudowane moduły, a mianowicie moduł csv i funkcję reader (). Poniżej znajduje się przykład ładowania pliku danych CSV za jego pomocą -
Przykład
W tym przykładzie używamy zestawu danych kwiatu tęczówki, który można pobrać do naszego katalogu lokalnego. Po załadowaniu pliku danych możemy go przekonwertować na tablicę NumPy i wykorzystać do projektów ML. Poniżej znajduje się skrypt Pythona do ładowania pliku danych CSV -
Najpierw musimy zaimportować moduł csv dostarczony przez standardową bibliotekę Pythona w następujący sposób -
import csvNastępnie musimy zaimportować moduł Numpy do konwersji załadowanych danych na tablicę NumPy.
import numpy as npTeraz podaj pełną ścieżkę do pliku przechowywanego w naszym katalogu lokalnym, zawierającego plik danych CSV -
path = r"c:\iris.csv"Następnie użyj funkcji csv.reader (), aby odczytać dane z pliku CSV -
with open(path,'r') as f:
reader = csv.reader(f,delimiter = ',')
headers = next(reader)
data = list(reader)
data = np.array(data).astype(float)Możemy wydrukować nazwy nagłówków za pomocą następującego wiersza skryptu -
print(headers)Poniższy wiersz skryptu wypisze kształt danych, tj. Liczbę wierszy i kolumn w pliku -
print(data.shape)Następna linia skryptu da pierwsze trzy linie pliku danych -
print(data[:3])Output
['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
(150, 4)
[ [5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]
[4.7 3.2 1.3 0.2]]Załaduj plik CSV za pomocą NumPy
Innym podejściem do załadowania pliku danych CSV jest funkcja NumPy i numpy.loadtxt (). Poniżej znajduje się przykład ładowania pliku danych CSV za jego pomocą -
Przykład
W tym przykładzie korzystamy z zestawu danych Pima Indians Dataset zawierającego dane pacjentów z cukrzycą. Ten zbiór danych jest liczbowym zbiorem danych bez nagłówka. Można go również pobrać do naszego katalogu lokalnego. Po załadowaniu pliku danych możemy go przekonwertować na tablicę NumPy i wykorzystać do projektów ML. Poniżej znajduje się skrypt Pythona do ładowania pliku danych CSV -
from numpy import loadtxt
path = r"C:\pima-indians-diabetes.csv"
datapath= open(path, 'r')
data = loadtxt(datapath, delimiter=",")
print(data.shape)
print(data[:3])Wynik
(768, 9)
[ [ 6. 148. 72. 35. 0. 33.6 0.627 50. 1.]
[ 1. 85. 66. 29. 0. 26.6 0.351 31. 0.]
[ 8. 183. 64. 0. 0. 23.3 0.672 32. 1.]]Załaduj plik CSV z Pandami
Innym podejściem do załadowania pliku danych CSV jest użycie funkcji Pandas i pandas.read_csv (). Jest to bardzo elastyczna funkcja, która zwraca pandas.DataFrame, której można natychmiast użyć do kreślenia. Poniżej znajduje się przykład ładowania pliku danych CSV za jego pomocą -
Przykład
Tutaj zaimplementujemy dwa skrypty Pythona, pierwszy to zestaw danych Iris zawierający nagłówki, a drugi to zestaw danych Pima Indians Dataset, który jest liczbowym zestawem danych bez nagłówka. Oba zestawy danych można pobrać do katalogu lokalnego.
Script-1
Poniżej znajduje się skrypt Pythona do ładowania pliku danych CSV za pomocą Pandas on Iris Data set -
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
print(data[:3])
Output:
(150, 4)
sepal_length sepal_width petal_length petal_width
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2Script-2
Poniżej znajduje się skrypt w Pythonie do ładowania pliku danych CSV, wraz z podaniem nazw nagłówków, przy użyciu zestawu danych Pandas on Pima Indians Diabetes -
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.shape)
print(data[:3])Output
(768, 9)
preg plas pres skin test mass pedi age class
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1Różnicę między powyższymi trzema podejściami do ładowania pliku danych CSV można łatwo zrozumieć na podstawie podanych przykładów.
Wprowadzenie
Podczas pracy z projektami uczenia maszynowego zazwyczaj pomijamy dwie najważniejsze części, tzw mathematics i data. Dzieje się tak, ponieważ wiemy, że ML jest podejściem opartym na danych, a nasz model ML da tylko tak dobre lub tak złe wyniki, jak dane, które mu przekazaliśmy.
W poprzednim rozdziale omówiliśmy, w jaki sposób możemy przesłać dane CSV do naszego projektu ML, ale dobrze byłoby zapoznać się z danymi przed ich przesłaniem. Możemy zrozumieć dane na dwa sposoby, za pomocą statystyk i wizualizacji.
W tym rozdziale, korzystając z przepisów Pythona, zrozumiemy dane ML ze statystykami.
Patrząc na surowe dane
Pierwszy przepis dotyczy przeglądania surowych danych. Ważne jest, aby spojrzeć na surowe dane, ponieważ wgląd, jaki uzyskamy po spojrzeniu na surowe dane, zwiększy nasze szanse na lepsze przetwarzanie wstępne, a także obsługę danych dla projektów ML.
Poniżej znajduje się skrypt Pythona zaimplementowany przy użyciu funkcji head () z Pandas DataFrame w zbiorze danych dotyczących cukrzycy Pima Indians, aby przyjrzeć się pierwszym 50 wierszom i lepiej je zrozumieć -
Przykład
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.head(50))Wynik
preg plas pres skin test mass pedi age class
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1
5 5 116 74 0 0 25.6 0.201 30 0
6 3 78 50 32 88 31.0 0.248 26 1
7 10 115 0 0 0 35.3 0.134 29 0
8 2 197 70 45 543 30.5 0.158 53 1
9 8 125 96 0 0 0.0 0.232 54 1
10 4 110 92 0 0 37.6 0.191 30 0
11 10 168 74 0 0 38.0 0.537 34 1
12 10 139 80 0 0 27.1 1.441 57 0
13 1 189 60 23 846 30.1 0.398 59 1
14 5 166 72 19 175 25.8 0.587 51 1
15 7 100 0 0 0 30.0 0.484 32 1
16 0 118 84 47 230 45.8 0.551 31 1
17 7 107 74 0 0 29.6 0.254 31 1
18 1 103 30 38 83 43.3 0.183 33 0
19 1 115 70 30 96 34.6 0.529 32 1
20 3 126 88 41 235 39.3 0.704 27 0
21 8 99 84 0 0 35.4 0.388 50 0
22 7 196 90 0 0 39.8 0.451 41 1
23 9 119 80 35 0 29.0 0.263 29 1
24 11 143 94 33 146 36.6 0.254 51 1
25 10 125 70 26 115 31.1 0.205 41 1
26 7 147 76 0 0 39.4 0.257 43 1
27 1 97 66 15 140 23.2 0.487 22 0
28 13 145 82 19 110 22.2 0.245 57 0
29 5 117 92 0 0 34.1 0.337 38 0
30 5 109 75 26 0 36.0 0.546 60 0
31 3 158 76 36 245 31.6 0.851 28 1
32 3 88 58 11 54 24.8 0.267 22 0
33 6 92 92 0 0 19.9 0.188 28 0
34 10 122 78 31 0 27.6 0.512 45 0
35 4 103 60 33 192 24.0 0.966 33 0
36 11 138 76 0 0 33.2 0.420 35 0
37 9 102 76 37 0 32.9 0.665 46 1
38 2 90 68 42 0 38.2 0.503 27 1
39 4 111 72 47 207 37.1 1.390 56 1
40 3 180 64 25 70 34.0 0.271 26 0
41 7 133 84 0 0 40.2 0.696 37 0
42 7 106 92 18 0 22.7 0.235 48 0
43 9 171 110 24 240 45.4 0.721 54 1
44 7 159 64 0 0 27.4 0.294 40 0
45 0 180 66 39 0 42.0 1.893 25 1
46 1 146 56 0 0 29.7 0.564 29 0
47 2 71 70 27 0 28.0 0.586 22 0
48 7 103 66 32 0 39.1 0.344 31 1
49 7 105 0 0 0 0.0 0.305 24 0Z powyższego wyniku możemy zauważyć, że pierwsza kolumna podaje numer wiersza, który może być bardzo przydatny do odniesienia się do określonej obserwacji.
Sprawdzanie wymiarów danych
Zawsze dobrze jest wiedzieć, ile danych w zakresie wierszy i kolumn mamy dla naszego projektu ML. Powody tego są -
Załóżmy, że jeśli mamy zbyt wiele wierszy i kolumn, uruchomienie algorytmu i nauczenie modelu zajęłoby dużo czasu.
Załóżmy, że jeśli mamy za mało wierszy i kolumn, to nie mielibyśmy wystarczającej ilości danych, aby dobrze wytrenować model.
Poniżej znajduje się skrypt Pythona zaimplementowany przez wydrukowanie właściwości shape w ramce danych Pandas. Zamierzamy go zaimplementować na zestawie danych tęczówki, aby uzyskać całkowitą liczbę wierszy i kolumn w nim.
Przykład
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)Wynik
(150, 4)Na podstawie danych wyjściowych możemy łatwo zauważyć, że zbiór danych tęczówki, którego zamierzamy użyć, ma 150 wierszy i 4 kolumny.
Pobieranie typu danych każdego atrybutu
Inną dobrą praktyką jest znajomość typu danych każdego atrybutu. Powodem jest to, że zgodnie z wymaganiami czasami może być konieczne przekonwertowanie jednego typu danych na inny. Na przykład może być konieczne przekonwertowanie ciągu znaków na zmiennoprzecinkowe lub int w celu przedstawienia wartości jakościowych lub porządkowych. Możemy mieć pojęcie o typie danych atrybutu, patrząc na surowe dane, ale innym sposobem jest użycie właściwości dtypes Pandas DataFrame. Za pomocą właściwości dtypes możemy kategoryzować każdy typ danych atrybutów. Można to zrozumieć za pomocą następującego skryptu Pythona -
Przykład
from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.dtypes)Wynik
sepal_length float64
sepal_width float64
petal_length float64
petal_width float64
dtype: objectZ powyższego wyniku możemy łatwo uzyskać typy danych każdego atrybutu.
Statystyczne podsumowanie danych
Omówiliśmy przepis Pythona, aby uzyskać kształt, tj. Liczbę wierszy i kolumn danych, ale wiele razy musimy przeglądać podsumowania z tego kształtu danych. Można to zrobić za pomocą funkcji opisywania () w Pandas DataFrame, która dodatkowo dostarcza następujących 8 właściwości statystycznych każdego atrybutu danych -
Count
Mean
Odchylenie standardowe
Minimalna wartość
Maksymalna wartość
25%
Mediana tj. 50%
75%
Przykład
from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
print(data.shape)
print(data.describe())Wynik
(768, 9)
preg plas pres skin test mass pedi age class
count 768.00 768.00 768.00 768.00 768.00 768.00 768.00 768.00 768.00
mean 3.85 120.89 69.11 20.54 79.80 31.99 0.47 33.24 0.35
std 3.37 31.97 19.36 15.95 115.24 7.88 0.33 11.76 0.48
min 0.00 0.00 0.00 0.00 0.00 0.00 0.08 21.00 0.00
25% 1.00 99.00 62.00 0.00 0.00 27.30 0.24 24.00 0.00
50% 3.00 117.00 72.00 23.00 30.50 32.00 0.37 29.00 0.00
75% 6.00 140.25 80.00 32.00 127.25 36.60 0.63 41.00 1.00
max 17.00 199.00 122.00 99.00 846.00 67.10 2.42 81.00 1.00Z powyższego wyniku możemy obserwować statystyczne podsumowanie danych zbioru danych Pima Indian Diabetes wraz z kształtem danych.
Przeglądanie rozkładu klas
Statystyka dystrybucji klas jest przydatna w problemach klasyfikacyjnych, w których musimy znać równowagę wartości klas. Ważne jest, aby znać rozkład wartości klas, ponieważ jeśli mamy wysoce niezrównoważony rozkład klas, tj. Jedna klasa ma o wiele więcej obserwacji niż inna klasa, może to wymagać specjalnego traktowania na etapie przygotowania danych w naszym projekcie ML. Możemy łatwo uzyskać dystrybucję klas w Pythonie za pomocą Pandas DataFrame.
Przykład
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
count_class = data.groupby('class').size()
print(count_class)Wynik
Class
0 500
1 268
dtype: int64Z powyższego wyniku można wyraźnie zauważyć, że liczba obserwacji z klasą 0 jest prawie dwukrotnie większa niż liczba obserwacji z klasą 1.
Przeglądanie korelacji między atrybutami
Związek między dwiema zmiennymi nazywa się korelacją. W statystyce najpowszechniejszą metodą obliczania korelacji jest współczynnik korelacji Pearsona. Może mieć trzy wartości w następujący sposób -
Coefficient value = 1 - To reprezentuje pełne positive korelacja między zmiennymi.
Coefficient value = -1 - To reprezentuje pełne negative korelacja między zmiennymi.
Coefficient value = 0 - To reprezentuje no korelacja między zmiennymi.
Zawsze dobrze jest przejrzeć parami korelacje atrybutów w naszym zbiorze danych przed użyciem go w projekcie ML, ponieważ niektóre algorytmy uczenia maszynowego, takie jak regresja liniowa i regresja logistyczna, będą działać słabo, jeśli mamy wysoce skorelowane atrybuty. W Pythonie możemy łatwo obliczyć macierz korelacji atrybutów zestawu danych za pomocą funkcji corr () w Pandas DataFrame.
Przykład
from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
correlations = data.corr(method='pearson')
print(correlations)Wynik
preg plas pres skin test mass pedi age class
preg 1.00 0.13 0.14 -0.08 -0.07 0.02 -0.03 0.54 0.22
plas 0.13 1.00 0.15 0.06 0.33 0.22 0.14 0.26 0.47
pres 0.14 0.15 1.00 0.21 0.09 0.28 0.04 0.24 0.07
skin -0.08 0.06 0.21 1.00 0.44 0.39 0.18 -0.11 0.07
test -0.07 0.33 0.09 0.44 1.00 0.20 0.19 -0.04 0.13
mass 0.02 0.22 0.28 0.39 0.20 1.00 0.14 0.04 0.29
pedi -0.03 0.14 0.04 0.18 0.19 0.14 1.00 0.03 0.17
age 0.54 0.26 0.24 -0.11 -0.04 0.04 0.03 1.00 0.24
class 0.22 0.47 0.07 0.07 0.13 0.29 0.17 0.24 1.00Macierz w powyższym wyniku podaje korelację między wszystkimi parami atrybutu w zbiorze danych.
Przeglądanie pochylenia rozkładu atrybutów
Skośność można zdefiniować jako rozkład, który przyjmuje się jako rozkład Gaussa, ale wydaje się zniekształcony lub przesunięty w jednym lub drugim kierunku albo w lewo lub w prawo. Przeglądanie skośności atrybutów jest jednym z ważnych zadań z następujących powodów -
Obecność skośności danych wymaga korekty na etapie przygotowania danych, abyśmy mogli uzyskać większą dokładność z naszego modelu.
Większość algorytmów ML zakłada, że dane mają rozkład Gaussa, tj. Albo dane normalne, albo dane o krzywej dzwonowej.
W Pythonie możemy łatwo obliczyć pochylenie każdego atrybutu, używając funkcji skew () w Pandas DataFrame.
Przykład
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
print(data.skew())Wynik
preg 0.90
plas 0.17
pres -1.84
skin 0.11
test 2.27
mass -0.43
pedi 1.92
age 1.13
class 0.64
dtype: float64Z powyższego wyniku można zaobserwować dodatnie lub ujemne odchylenie. Jeśli wartość jest bliższa zeru, pokazuje mniejsze pochylenie.
Wprowadzenie
W poprzednim rozdziale omówiliśmy znaczenie danych dla algorytmów uczenia maszynowego wraz z niektórymi regułami języka Python w celu zrozumienia danych ze statystykami. Istnieje inny sposób, zwany wizualizacją, służący do zrozumienia danych.
Za pomocą wizualizacji danych możemy zobaczyć, jak wyglądają dane i jaki rodzaj korelacji posiadają atrybuty danych. Jest to najszybszy sposób sprawdzenia, czy funkcje odpowiadają wynikowi. Korzystając z przepisów Pythona, możemy zrozumieć dane ML ze statystykami.
Wykresy jednowymiarowe: niezależne zrozumienie atrybutów
Najprostszym typem wizualizacji jest wizualizacja z jedną zmienną lub „jednowymiarowa”. Przy pomocy wizualizacji jednowymiarowej możemy niezależnie zrozumieć każdy atrybut naszego zbioru danych. Poniżej przedstawiono niektóre techniki w Pythonie do implementacji wizualizacji jednowymiarowej -
Histogramy
Histogramy grupują dane w koszach i są najszybszym sposobem na uzyskanie informacji o rozmieszczeniu każdego atrybutu w zbiorze danych. Oto niektóre cechy charakterystyczne histogramów -
Zapewnia nam liczbę obserwacji w każdym koszu utworzonym do wizualizacji.
Z kształtu kosza można łatwo zaobserwować rozkład, czyli pogodę jest to gaussowskie, skośne lub wykładnicze.
Histogramy pomagają nam również dostrzec możliwe wartości odstające.
Przykład
Poniższy kod jest przykładem skryptu w języku Python tworzącego histogram atrybutów zbioru danych Pima Indian Diabetes. Tutaj będziemy używać funkcji hist () na Pandas DataFrame do generowania histogramów imatplotlib za spiskowanie ich.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.hist()
pyplot.show()Wynik
Powyższe dane wyjściowe pokazują, że utworzył histogram dla każdego atrybutu w zestawie danych. Z tego możemy zauważyć, że być może wiek, pedi i atrybut testowy mogą mieć rozkład wykładniczy, podczas gdy masa i plazma mają rozkład Gaussa.
Wykresy gęstości
Inną szybką i łatwą techniką uzyskania rozkładu poszczególnych atrybutów są wykresy gęstości. Jest również podobny do histogramu, ale ma gładką krzywą narysowaną przez górę każdego pojemnika. Możemy je nazwać abstrakcyjnymi histogramami.
Przykład
W poniższym przykładzie skrypt w języku Python wygeneruje wykresy gęstości dla dystrybucji atrybutów zestawu danych Pima Indian Diabetes.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.show()Wynik
Z powyższego wyniku można łatwo zrozumieć różnicę między wykresami gęstości a histogramami.
Wykresy pudełkowe i wąsy
Wykresy pudełkowe i wąsy, w skrócie zwane również wykresami pudełkowymi, to kolejna przydatna technika do przeglądu rozkładu każdego atrybutu. Poniżej przedstawiono cechy tej techniki -
Ma charakter jednoczynnikowy i podsumowuje rozkład każdego atrybutu.
Rysuje linię dla wartości środkowej, tj. Dla mediany.
Rysuje prostokąt wokół 25% i 75%.
Rysuje również wąsy, które dają nam wyobrażenie o rozprzestrzenianiu się danych.
Kropki poza wąsami oznaczają wartości odstające. Wartości odstające byłyby 1,5 raza większe niż rozmiar rozprzestrzeniania się średnich danych.
Przykład
W poniższym przykładzie skrypt w języku Python wygeneruje wykresy gęstości dla dystrybucji atrybutów zestawu danych Pima Indian Diabetes.
from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='box', subplots=True, layout=(3,3), sharex=False,sharey=False)
pyplot.show()Wynik
Z powyższego wykresu rozkładu atrybutu można zauważyć, że wiek, test i skóra wydają się być pochylone w kierunku mniejszych wartości.
Wykresy wielowymiarowe: interakcja między wieloma zmiennymi
Innym rodzajem wizualizacji jest wizualizacja z wieloma zmiennymi lub „wielowymiarowymi”. Przy pomocy wizualizacji wielowymiarowej możemy zrozumieć interakcje między wieloma atrybutami naszego zbioru danych. Poniżej przedstawiono niektóre techniki w Pythonie do implementacji wizualizacji wielowymiarowej -
Wykres macierzy korelacji
Korelacja jest wskazówką dotyczącą zmian między dwiema zmiennymi. W naszych poprzednich rozdziałach omówiliśmy współczynniki korelacji Pearsona i znaczenie korelacji. Możemy wykreślić macierz korelacji, aby pokazać, która zmienna ma wysoką lub niską korelację w odniesieniu do innej zmiennej.
Przykład
W poniższym przykładzie skrypt w języku Python wygeneruje i wykreśli macierz korelacji dla zestawu danych Pima Indian Diabetes. Można go wygenerować za pomocą funkcji corr () w Pandas DataFrame i wykreślić za pomocą pyplot.
from matplotlib import pyplot
from pandas import read_csv
import numpy
Path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(Path, names=names)
correlations = data.corr()
fig = pyplot.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = numpy.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
pyplot.show()Wynik
Z powyższego wyniku macierzy korelacji widzimy, że jest symetryczna, tj. Lewy dolny róg jest taki sam jak prawy górny. Obserwuje się również, że każda zmienna jest ze sobą dodatnio skorelowana.
Wykres macierzy rozproszenia
Wykresy punktowe pokazują, jak bardzo na jedną zmienną wpływa inna lub związek między nimi za pomocą kropek w dwóch wymiarach. Wykresy punktowe są bardzo podobne do wykresów liniowych w koncepcji, że używają osi poziomej i pionowej do wykreślania punktów danych.
Przykład
W poniższym przykładzie skrypt w języku Python wygeneruje i wykreśli macierz rozrzutu dla zestawu danych Pima Indian Diabetes. Można go wygenerować za pomocą funkcji scatter_matrix () w Pandas DataFrame i wykreślić za pomocą pyplot.
from matplotlib import pyplot
from pandas import read_csv
from pandas.tools.plotting import scatter_matrix
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
scatter_matrix(data)
pyplot.show()Wynik
Wprowadzenie
Algorytmy uczenia maszynowego są całkowicie zależne od danych, ponieważ jest to najważniejszy aspekt, który umożliwia uczenie modeli. Z drugiej strony, jeśli nie będziemy w stanie wyciągnąć sensu z tych danych, przed przekazaniem ich do algorytmów ML maszyna będzie bezużyteczna. Mówiąc prościej, zawsze musimy podawać właściwe dane, tj. Dane w odpowiedniej skali, formacie i zawierające znaczące cechy, dla problemu, który chcemy rozwiązać przez maszynę.
To sprawia, że przygotowanie danych jest najważniejszym krokiem w procesie ML. Przygotowanie danych można zdefiniować jako procedurę, która sprawia, że nasz zbiór danych jest bardziej odpowiedni dla procesu ML.
Dlaczego wstępne przetwarzanie danych?
Po wybraniu surowych danych do treningu ML najważniejszym zadaniem jest wstępne przetwarzanie danych. W szerokim sensie wstępne przetwarzanie danych przekształci wybrane dane w formę, z którą możemy pracować lub możemy je przesłać do algorytmów ML. Zawsze musimy wstępnie przetwarzać nasze dane, aby były zgodne z oczekiwaniami algorytmu uczenia maszynowego.
Techniki wstępnego przetwarzania danych
Mamy następujące techniki wstępnego przetwarzania danych, które można zastosować na zestawie danych w celu uzyskania danych dla algorytmów ML -
skalowanie
Najprawdopodobniej nasz zbiór danych zawiera atrybuty o różnej skali, ale nie możemy dostarczyć takich danych do algorytmu ML, dlatego wymaga przeskalowania. Przeskalowanie danych zapewnia, że atrybuty są w tej samej skali. Ogólnie atrybuty są przeskalowywane do zakresu od 0 do 1. Algorytmy ML, takie jak gradientowe zejście i k-Nearest Neighbors, wymagają skalowanych danych. Możemy przeskalować dane za pomocą klasy MinMaxScaler biblioteki scikit-learn Python.
Przykład
W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV (tak jak zostało to zrobione w poprzednich rozdziałach), a następnie przy pomocy klasy MinMaxScaler zostaną przeskalowane w zakresie 0 i 1.
Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych CSV.
from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesTeraz możemy użyć klasy MinMaxScaler do przeskalowania danych w zakresie od 0 do 1.
data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 1 i pokazujemy pierwsze 10 wierszy na wyjściu.
set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])Wynik
Scaled data:
[[0.4 0.7 0.6 0.4 0. 0.5 0.2 0.5 1. ]
[0.1 0.4 0.5 0.3 0. 0.4 0.1 0.2 0. ]
[0.5 0.9 0.5 0. 0. 0.3 0.3 0.2 1. ]
[0.1 0.4 0.5 0.2 0.1 0.4 0. 0. 0. ]
[0. 0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
[0.3 0.6 0.6 0. 0. 0.4 0.1 0.2 0. ]
[0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
[0.6 0.6 0. 0. 0. 0.5 0. 0.1 0. ]
[0.1 1. 0.6 0.5 0.6 0.5 0. 0.5 1. ]
[0.5 0.6 0.8 0. 0. 0. 0.1 0.6 1. ]]Z powyższego wyniku wszystkie dane zostały przeskalowane do zakresu 0 i 1.
Normalizacja
Inną przydatną techniką wstępnego przetwarzania danych jest normalizacja. Służy do przeskalowania każdego wiersza danych tak, aby miał długość 1. Jest to przydatne głównie w rzadkich zestawach danych, w których mamy dużo zer. Możemy przeskalować dane za pomocą klasy Normalizer biblioteki scikit-learn Python.
Rodzaje normalizacji
W uczeniu maszynowym istnieją dwa typy technik wstępnego przetwarzania normalizacji, jak następuje:
Normalizacja L1
Można ją zdefiniować jako technikę normalizacji, która modyfikuje wartości zbioru danych w taki sposób, że w każdym wierszu suma wartości bezwzględnych będzie zawsze wynosić do 1. Nazywa się ją również najmniejszymi odchyleniami bezwzględnymi.
Example
W tym przykładzie używamy techniki L1 Normalize do znormalizowania danych z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV, a następnie przy pomocy klasy Normalizer zostaną znormalizowane.
Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych CSV.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.valuesTeraz możemy użyć klasy Normalizer z L1 do normalizacji danych.
Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 3 wiersze na wyjściu.
set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])Output
Normalized data:
[[0.02 0.43 0.21 0.1 0. 0.1 0. 0.14 0. ]
[0. 0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
[0.03 0.59 0.21 0. 0. 0.07 0. 0.1 0. ]]Normalizacja L2
Można ją zdefiniować jako technikę normalizacji, która modyfikuje wartości zbioru danych w taki sposób, że w każdym wierszu suma kwadratów będzie zawsze wynosić do 1. Nazywa się ją również metodą najmniejszych kwadratów.
Example
W tym przykładzie używamy techniki L2 Normalization, aby znormalizować dane ze zbioru danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw dane CSV zostaną załadowane (tak jak zostało to zrobione w poprzednich rozdziałach), a następnie przy pomocy klasy Normalizer zostaną znormalizowane.
Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych CSV.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.valuesTeraz możemy użyć klasy Normalizer z L1 do normalizacji danych.
Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 3 wiersze na wyjściu.
set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])Output
Normalized data:
[[0.03 0.83 0.4 0.2 0. 0.19 0. 0.28 0.01]
[0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0. ]
[0.04 0.92 0.32 0. 0. 0.12 0. 0.16 0.01]]Binaryzacja
Jak sama nazwa wskazuje, jest to technika, za pomocą której możemy uczynić nasze dane binarnymi. Możemy użyć progu binarnego, aby uczynić nasze dane binarnymi. Wartości powyżej tej wartości progowej zostaną przekonwertowane na 1, a poniżej tego progu zostaną przekonwertowane na 0. Na przykład, jeśli wybierzemy wartość progową = 0,5, wówczas wartość zbioru danych powyżej tej wartości progowej będzie równa 1, a poniżej tej wartości - 0. To znaczy dlaczego możemy to nazwaćbinarizing dane lub thresholdingdane. Ta technika jest przydatna, gdy mamy prawdopodobieństwa w naszym zbiorze danych i chcemy przekształcić je w konkretne wartości.
Możemy binaryzować dane za pomocą klasy Binarizer z biblioteki Python scikit-learn.
Przykład
W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw zostaną załadowane dane CSV, a następnie przy pomocy klasy Binarizer zostaną przekonwertowane na wartości binarne tj. 0 i 1 w zależności od wartości progowej. Przyjmujemy 0,5 jako wartość progową.
Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych CSV.
from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesTeraz możemy użyć klasy Binarize do konwersji danych na wartości binarne.
binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)Tutaj pokazujemy pierwsze 5 wierszy danych wyjściowych.
print ("\nBinary data:\n", Data_binarized [0:5])Wynik
Binary data:
[[1. 1. 1. 1. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 0. 1. 0. 1. 0.]
[1. 1. 1. 0. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 0. 1. 0.]
[0. 1. 1. 1. 1. 1. 1. 1. 1.]]Normalizacja
Kolejna przydatna technika wstępnego przetwarzania danych, która jest zasadniczo używana do transformacji atrybutów danych z rozkładem Gaussa. Różni się średnią i odchyleniem standardowym (odchylenie standardowe) od standardowego rozkładu Gaussa ze średnią 0 i odchyleniem standardowym równym 1. Ta technika jest przydatna w algorytmach ML, takich jak regresja liniowa, regresja logistyczna, która zakłada rozkład Gaussa w wejściowym zbiorze danych i generuje lepsze wyniki z przeskalowanymi danymi. Możemy ustandaryzować dane (średnia = 0 i SD = 1) za pomocą klasy StandardScaler biblioteki scikit-learn Python.
Przykład
W tym przykładzie przeskalujemy dane z zestawu danych Pima Indians Diabetes, którego używaliśmy wcześniej. Najpierw dane CSV zostaną załadowane, a następnie przy pomocy klasy StandardScaler zostaną przekonwertowane na rozkład Gaussa ze średnią = 0 i SD = 1.
Pierwsze kilka wierszy poniższego skryptu jest takich samych, jak napisaliśmy w poprzednich rozdziałach podczas ładowania danych CSV.
from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesTeraz możemy użyć klasy StandardScaler do przeskalowania danych.
data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy pierwsze 5 wierszy na wyjściu.
set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])Wynik
Rescaled data:
[[ 0.64 0.85 0.15 0.91 -0.69 0.2 0.47 1.43 1.37]
[-0.84 -1.12 -0.16 0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
[ 1.23 1.94 -0.26 -1.29 -0.69 -1.1 0.6 -0.11 1.37]
[-0.84 -1. -0.16 0.15 0.12 -0.49 -0.92 -1.04 -0.73]
[-1.14 0.5 -1.5 0.91 0.77 1.41 5.48 -0.02 1.37]]Etykietowanie danych
Omówiliśmy znaczenie dobrego fata dla algorytmów ML, a także niektórych technik wstępnego przetwarzania danych przed wysłaniem ich do algorytmów ML. Jeszcze jednym aspektem w tym względzie jest etykietowanie danych. Bardzo ważne jest również przesłanie danych do algorytmów ML posiadających odpowiednie oznakowanie. Na przykład w przypadku problemów z klasyfikacją na danych znajduje się wiele etykiet w postaci słów, liczb itp.
Co to jest kodowanie etykiet?
Większość funkcji sklearn oczekuje, że dane będą miały etykiety liczbowe, a nie etykiety słów. Dlatego musimy zamienić takie etykiety na etykiety z numerami. Ten proces nazywa się kodowaniem etykiet. Możemy wykonać etykietowe kodowanie danych za pomocą funkcji LabelEncoder () biblioteki scikit-learn Python.
Przykład
W poniższym przykładzie skrypt Pythona wykona kodowanie etykiety.
Najpierw zaimportuj wymagane biblioteki Pythona w następujący sposób -
import numpy as np
from sklearn import preprocessingTeraz musimy podać etykiety wejściowe w następujący sposób -
input_labels = ['red','black','red','green','black','yellow','white']Następny wiersz kodu utworzy koder etykiet i wytrenuje go.
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)Kolejne wiersze skryptu sprawdzą wydajność, kodując losowo uporządkowaną listę -
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)Możemy uzyskać listę zakodowanych wartości za pomocą następującego skryptu w Pythonie -
print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))Wynik
Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']W poprzednim rozdziale szczegółowo omówiliśmy, jak wstępnie przetwarzać i przygotowywać dane do uczenia maszynowego. W tym rozdziale wyjaśnimy szczegółowo wybór cech danych i różne aspekty z tym związane.
Znaczenie wyboru funkcji danych
Wydajność modelu uczenia maszynowego jest wprost proporcjonalna do funkcji danych używanych do jego trenowania. Na wydajność modelu ML wpłynie to negatywnie, jeśli dostarczone mu funkcje danych są nieistotne. Z drugiej strony użycie odpowiednich funkcji danych może zwiększyć dokładność modelu ML, zwłaszcza regresji liniowej i logistycznej.
Teraz pojawia się pytanie, czym jest automatyczny dobór funkcji? Można go zdefiniować jako proces, za pomocą którego wybieramy te cechy w naszych danych, które są najbardziej odpowiednie dla zmiennej wyjściowej lub predykcyjnej, którymi jesteśmy zainteresowani. Nazywa się to również wyborem atrybutów.
Poniżej przedstawiono niektóre korzyści wynikające z automatycznego wyboru funkcji przed modelowaniem danych -
Dokonanie wyboru funkcji przed modelowaniem danych zmniejszy nadmierne dopasowanie.
Wykonywanie wyboru funkcji przed modelowaniem danych zwiększy dokładność modelu ML.
Dokonanie wyboru funkcji przed modelowaniem danych skróci czas szkolenia
Techniki wyboru funkcji
Poniżej przedstawiono techniki automatycznego wyboru funkcji, których możemy użyć do modelowania danych ML w Pythonie -
Wybór jednowymiarowy
Ta technika wyboru cech jest bardzo przydatna przy wybieraniu tych cech, przy pomocy testów statystycznych, mających najsilniejszy związek ze zmiennymi predykcji. Możemy zaimplementować technikę jednoczynnikowego wyboru cech za pomocą SelectKBest0class biblioteki scikit-learn Python.
Example
W tym przykładzie użyjemy zbioru danych Pima Indians Diabetes, aby wybrać 4 atrybuty o najlepszych cechach za pomocą testu statystycznego chi-kwadrat.
from pandas import read_csv
from numpy import set_printoptions
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesNastępnie podzielimy tablicę na komponenty wejściowe i wyjściowe -
X = array[:,0:8]
Y = array[:,8]Poniższe wiersze kodu wybiorą najlepsze funkcje z zestawu danych -
test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X,Y)Możemy również podsumować dane wyjściowe według naszego wyboru. Tutaj ustawiamy dokładność na 2 i pokazujemy 4 atrybuty danych z najlepszymi funkcjami wraz z najlepszym wynikiem każdego atrybutu -
set_printoptions(precision=2)
print(fit.scores_)
featured_data = fit.transform(X)
print ("\nFeatured data:\n", featured_data[0:4])Output
[ 111.52 1411.89 17.61 53.11 2175.57 127.67 5.39 181.3 ]
Featured data:
[[148. 0. 33.6 50. ]
[ 85. 0. 26.6 31. ]
[183. 0. 23.3 32. ]
[ 89. 94. 28.1 21. ]]Rekurencyjna eliminacja funkcji
Jak sama nazwa wskazuje, technika wyboru cech RFE (rekurencyjna eliminacja cech) usuwa atrybuty rekurencyjnie i buduje model z pozostałymi atrybutami. Możemy zaimplementować technikę wyboru cech RFE za pomocą klasy RFE biblioteki Python scikit-learn.
Przykład
W tym przykładzie użyjemy RFE z algorytmem regresji logistycznej, aby wybrać 3 najlepsze atrybuty mające najlepsze cechy z zestawu danych Pima Indians Diabetes do.
from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesNastępnie podzielimy tablicę na komponenty wejściowe i wyjściowe -
X = array[:,0:8]
Y = array[:,8]Poniższe wiersze kodu wybiorą najlepsze funkcje ze zbioru danych -
model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Number of Features: %d")
print("Selected Features: %s")
print("Feature Ranking: %s")Wynik
Number of Features: 3
Selected Features: [ True False False False False True True False]
Feature Ranking: [1 2 3 5 6 1 1 4]Jak widać na powyższym wyjściu, RFE wybiera preg, mass i pedi jako pierwsze 3 najlepsze cechy. Na wyjściu są oznaczone jako 1.
Analiza głównych składników (PCA)
PCA, ogólnie nazywana techniką redukcji danych, jest bardzo przydatną techniką wyboru cech, ponieważ wykorzystuje algebrę liniową do przekształcenia zbioru danych w formę skompresowaną. Możemy zaimplementować technikę wyboru cech PCA przy pomocy klasy PCA biblioteki scikit-learn Python. W wyniku możemy wybrać liczbę głównych składników.
Przykład
W tym przykładzie użyjemy PCA do wybrania 3 najlepszych głównych komponentów ze zbioru danych Pima Indians Diabetes.
from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.valuesNastępnie podzielimy tablicę na komponenty wejściowe i wyjściowe -
X = array[:,0:8]
Y = array[:,8]Poniższe wiersze kodu wyodrębnią funkcje z zestawu danych -
pca = PCA(n_components=3)
fit = pca.fit(X)
print("Explained Variance: %s") % fit.explained_variance_ratio_
print(fit.components_)Wynik
Explained Variance: [ 0.88854663 0.06159078 0.02579012]
[[ -2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02
9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[ 2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02
-9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01]
[ -2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01
2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]Na podstawie powyższego wyniku możemy zauważyć, że 3 główne składniki wykazują niewielkie podobieństwo do danych źródłowych.
Znaczenie funkcji
Jak sama nazwa wskazuje, do wyboru cech ważności używa się techniki ważności cech. Zasadniczo używa wyszkolonego nadzorowanego klasyfikatora do wybierania funkcji. Możemy zaimplementować tę technikę wyboru cech za pomocą klasy ExtraTreeClassifier biblioteki scikit-learn Python.
Przykład
W tym przykładzie użyjemy ExtraTreeClassifier do wybrania funkcji z zestawu danych Pima Indians Diabetes.
from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
path = r'C:\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(data, names=names)
array = dataframe.valuesNastępnie podzielimy tablicę na komponenty wejściowe i wyjściowe -
X = array[:,0:8]
Y = array[:,8]Poniższe wiersze kodu wyodrębnią funkcje z zestawu danych -
model = ExtraTreesClassifier()
model.fit(X, Y)
print(model.feature_importances_)Wynik
[ 0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]Na podstawie wyników możemy zauważyć, że dla każdego atrybutu są oceny. Im wyższy wynik, tym większe znaczenie tego atrybutu.
Wprowadzenie do klasyfikacji
Klasyfikację można zdefiniować jako proces przewidywania klasy lub kategorii na podstawie obserwowanych wartości lub danych punktów. Skategoryzowane dane wyjściowe mogą mieć postać, na przykład „Czarny” lub „Biały”, „Spam” lub „Brak spamu”.
Matematycznie, klasyfikacja to zadanie przybliżenia funkcji odwzorowującej (f) ze zmiennych wejściowych (X) do zmiennych wyjściowych (Y). Zasadniczo należy do nadzorowanego uczenia maszynowego, w którym cele są również dostarczane wraz z zestawem danych wejściowych.
Przykładem problemu klasyfikacyjnego może być wykrywanie spamu w wiadomościach e-mail. Mogą istnieć tylko dwie kategorie wyników, „spam” i „brak spamu”; stąd jest to klasyfikacja typu binarnego.
Aby zaimplementować tę klasyfikację, musimy najpierw przeszkolić klasyfikator. W tym przykładzie wiadomości e-mail „spam” i „bez spamu” zostaną użyte jako dane szkoleniowe. Po pomyślnym przeszkoleniu klasyfikatora można go użyć do wykrycia nieznanej wiadomości e-mail.
Typy uczniów w klasyfikacji
Mamy dwa typy uczniów w odniesieniu do problemów klasyfikacyjnych -
Leniwi uczniowie
Jak sama nazwa wskazuje, tego typu uczniowie czekają na pojawienie się danych testowych po zapisaniu danych treningowych. Klasyfikacja następuje dopiero po uzyskaniu danych testowych. Spędzają mniej czasu na treningu, ale więcej na prognozowaniu. Przykłady leniwych uczniów to najbliższy sąsiad K i rozumowanie oparte na przypadkach.
Chętni uczniowie
W przeciwieństwie do leniwych uczniów, chętni uczący się konstruują model klasyfikacji bez czekania na pojawienie się danych testowych po ich zapisaniu. Spędzają więcej czasu na treningu, ale mniej na przewidywaniu. Przykładami chętnych do nauki są drzewa decyzyjne, naiwne Bayes i sztuczne sieci neuronowe (ANN).
Budowanie klasyfikatora w Pythonie
Scikit-learn, biblioteka Pythona do uczenia maszynowego, może zostać użyta do zbudowania klasyfikatora w Pythonie. Kroki tworzenia klasyfikatora w Pythonie są następujące -
Krok 1: Importowanie niezbędnego pakietu Pythona
Aby zbudować klasyfikator przy użyciu scikit-learn, musimy go zaimportować. Możemy go zaimportować za pomocą następującego skryptu -
import sklearnKrok 2: Importowanie zbioru danych
Po zaimportowaniu niezbędnego pakietu potrzebujemy zbioru danych do zbudowania modelu predykcyjnego klasyfikacji. Możemy zaimportować go z zestawu danych sklearn lub użyć innego, zgodnie z naszymi wymaganiami. Zamierzamy skorzystać z Diagnostycznej Bazy Danych Sklearn Breast Cancer Wisconsin. Możemy go zaimportować za pomocą następującego skryptu -
from sklearn.datasets import load_breast_cancerPoniższy skrypt załaduje zestaw danych;
data = load_breast_cancer()Musimy również uporządkować dane i można to zrobić za pomocą następujących skryptów -
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']Następujące polecenie wypisze nazwy etykiet, „złośliwe” i „łagodne” w przypadku naszej bazy danych.
print(label_names)Wynikiem powyższego polecenia są nazwy etykiet -
['malignant' 'benign']Te etykiety są mapowane na wartości binarne 0 i 1. Malignant rak jest reprezentowany przez 0 i Benign rak jest reprezentowany przez 1.
Nazwy funkcji i wartości funkcji tych etykiet można zobaczyć za pomocą następujących poleceń -
print(feature_names[0])Wynikiem powyższego polecenia są nazwy funkcji dla etykiety 0 tj Malignant rak -
mean radiusPodobnie nazwy cech dla etykiety mogą być tworzone w następujący sposób -
print(feature_names[1])Wynikiem powyższego polecenia są nazwy funkcji dla etykiety 1 tj Benign rak -
mean textureMożemy wydrukować cechy tych etykiet za pomocą następującego polecenia -
print(features[0])To da następujący wynik -
[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
4.601e-01 1.189e-01]Możemy wydrukować cechy tych etykiet za pomocą następującego polecenia -
print(features[1])To da następujący wynik -
[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01 8.902e-02]Krok 3: Organizowanie danych w zestawy szkoleniowe i testowe
Ponieważ musimy przetestować nasz model na niewidocznych danych, podzielimy nasz zbiór danych na dwie części: zbiór uczący i zbiór testowy. Możemy użyć funkcji train_test_split () pakietu sklearn python, aby podzielić dane na zbiory. Następujące polecenie zaimportuje funkcję -
from sklearn.model_selection import train_test_splitTeraz następne polecenie podzieli dane na dane treningowe i testowe. W tym przykładzie wykorzystujemy pobieranie 40 procent danych do celów testowych i 60 procent danych do celów szkoleniowych -
train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)Krok 4 - Ocena modelu
Po podzieleniu danych na treningi i testy musimy zbudować model. W tym celu wykorzystamy algorytm Naïve Bayes. Następujące polecenia zaimportują moduł GaussianNB -
from sklearn.naive_bayes import GaussianNBTeraz zainicjalizuj model w następujący sposób -
gnb = GaussianNB()Następnie za pomocą następującego polecenia możemy wytrenować model -
model = gnb.fit(train, train_labels)Teraz, dla celów oceny, musimy robić prognozy. Można to zrobić za pomocą funkcji Predict () w następujący sposób -
preds = gnb.predict(test)
print(preds)To da następujący wynik -
[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
0 0 1 1 0 1]Powyższe szeregi zer i jedynek na wyjściu są przewidywanymi wartościami dla Malignant i Benign klasy nowotworów.
Krok 5 - Znalezienie dokładności
Możemy znaleźć dokładność modelu zbudowanego w poprzednim kroku, porównując dwie tablice, mianowicie test_labels i preds. Do określenia dokładności będziemy używać funkcji dokładności_score ().
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965Powyższe dane wyjściowe pokazują, że klasyfikator NaïveBayes jest dokładny w 95,17%.
Wskaźniki oceny klasyfikacji
Zadanie nie jest wykonywane, nawet jeśli zakończono wdrażanie aplikacji lub modelu uczenia maszynowego. Musimy się dowiedzieć, jak skuteczny jest nasz model? Mogą istnieć różne metryki oceny, ale musimy je starannie wybrać, ponieważ wybór metryk wpływa na sposób mierzenia i porównywania wydajności algorytmu uczenia maszynowego.
Poniżej przedstawiono niektóre z ważnych metryk oceny klasyfikacji, spośród których możesz wybrać na podstawie zbioru danych i rodzaju problemu -
Macierz zamieszania
Jest to najłatwiejszy sposób pomiaru wydajności problemu klasyfikacji, w którym wynik może składać się z dwóch lub więcej typów klas. Macierz zamieszania to nic innego jak stół o dwóch wymiarach, a mianowicie. „Rzeczywiste” i „Przewidywane”, a ponadto oba wymiary mają „Prawdziwie pozytywne (TP)”, „Prawdziwie negatywne (TN)”, „Fałszywie dodatnie (FP)”, „Fałszywie negatywne (FN)”, jak pokazano poniżej -
True Positives (TP) - Dzieje się tak, gdy zarówno aktualna klasa, jak i przewidywana klasa punktu danych to 1.
True Negatives (TN) - Dzieje się tak, gdy zarówno aktualna klasa, jak i przewidywana klasa punktu danych mają wartość 0.
False Positives (FP) - Tak jest w przypadku, gdy aktualna klasa punktu danych to 0, a przewidywana klasa punktu danych to 1.
False Negatives (FN) - Tak jest w przypadku, gdy aktualna klasa punktu danych to 1, a przewidywana klasa punktu danych to 0.
Macierz pomyłki możemy znaleźć za pomocą funkcji confusion_matrix () funkcji sklearn. Za pomocą poniższego skryptu możemy znaleźć macierz pomyłki powyższego klasyfikatora binarnego -
from sklearn.metrics import confusion_matrixWynik
[[ 73 7]
[ 4 144]]Precyzja
Można to zdefiniować jako liczbę poprawnych prognoz wykonanych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$$=\frac{+}{+++}$$Dla wyżej zbudowanego klasyfikatora binarnego TP + TN = 73 + 144 = 217 i TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.
Stąd Dokładność = 217/228 = 0,951754385965, czyli to samo, co obliczyliśmy po utworzeniu naszego klasyfikatora binarnego.
Precyzja
Precyzja wykorzystywana przy pobieraniu dokumentów może być zdefiniowana jako liczba poprawnych dokumentów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$$=\frac{}{+FP}$$Dla powyższego klasyfikatora binarnego TP = 73 i TP + FP = 73 + 7 = 80.
Stąd Precyzja = 73/80 = 0,915
Przypomnienie lub wrażliwość
Recall można zdefiniować jako liczbę pozytywów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$$=\frac{}{+FN}$$Dla wyżej zbudowanego klasyfikatora binarnego TP = 73 i TP + FN = 73 + 4 = 77.
Stąd Precyzja = 73/77 = 0,94805
Specyficzność
Specyficzność, w przeciwieństwie do przypominania, można zdefiniować jako liczbę negatywów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$$=\frac{N}{N+FP}$$Dla powyższego klasyfikatora binarnego TN = 144 i TN + FP = 144 + 7 = 151.
Stąd Precyzja = 144/151 = 0,95364
Różne algorytmy klasyfikacji ML
Poniżej przedstawiono kilka ważnych algorytmów klasyfikacji ML -
Regresja logistyczna
Maszyna wektorów wsparcia (SVM)
Drzewo decyzyjne
Naïve Bayes
Losowy las
W dalszych rozdziałach omówimy szczegółowo wszystkie te algorytmy klasyfikacji.
Aplikacje
Oto niektóre z najważniejszych zastosowań algorytmów klasyfikacyjnych -
Rozpoznawanie mowy
Rozpoznawanie pisma odręcznego
Identyfikacja biometryczna
Klasyfikacja dokumentów
Wprowadzenie do regresji logistycznej
Regresja logistyczna to nadzorowany algorytm klasyfikacji uczenia się używany do przewidywania prawdopodobieństwa zmiennej docelowej. Charakter zmiennej docelowej lub zależnej jest dychotomiczny, co oznacza, że byłyby tylko dwie możliwe klasy.
Mówiąc prościej, zmienna zależna ma charakter binarny i ma dane zakodowane jako 1 (oznacza sukces / tak) lub 0 (oznacza niepowodzenie / nie).
Matematycznie model regresji logistycznej przewiduje P (Y = 1) jako funkcję X. Jest to jeden z najprostszych algorytmów ML, który można wykorzystać do różnych problemów klasyfikacyjnych, takich jak wykrywanie spamu, przewidywanie cukrzycy, wykrywanie raka itp.
Rodzaje regresji logistycznej
Ogólnie regresja logistyczna oznacza binarną regresję logistyczną z binarnymi zmiennymi docelowymi, ale mogą istnieć jeszcze dwie kategorie zmiennych docelowych, które można na jej podstawie przewidzieć. W oparciu o tę liczbę kategorii regresję logistyczną można podzielić na następujące typy -
Binarny lub dwumianowy
W takiej klasyfikacji zmienna zależna będzie miała tylko dwa możliwe typy 1 i 0. Na przykład zmienne te mogą reprezentować sukces lub porażkę, tak lub nie, wygraną lub przegraną itp.
Wielomian
W takiej klasyfikacji zmienna zależna może mieć 3 lub więcej możliwych typów nieuporządkowanych lub typów, które nie mają znaczenia ilościowego. Na przykład te zmienne mogą reprezentować „Typ A”, „Typ B” lub „Typ C”.
Porządkowy
W takiej klasyfikacji zmienna zależna może mieć 3 lub więcej możliwych typów uporządkowanych lub typów mających znaczenie ilościowe. Na przykład zmienne te mogą oznaczać „słabe” lub „dobre”, „bardzo dobre”, „doskonałe”, a każda kategoria może mieć wyniki takie jak 0,1,2,3.
Założenia regresji logistycznej
Zanim zagłębimy się w implementację regresji logistycznej, musimy zdawać sobie sprawę z następujących założeń dotyczących tego samego -
W przypadku binarnej regresji logistycznej zmienne docelowe muszą być zawsze binarne, a pożądany wynik jest reprezentowany przez poziom czynnika 1.
W modelu nie powinno być żadnych współliniowości, co oznacza, że zmienne niezależne muszą być od siebie niezależne.
W naszym modelu musimy uwzględnić znaczące zmienne.
Do regresji logistycznej powinniśmy wybrać dużą próbę.
Binarny model regresji logistycznej
Najprostszą formą regresji logistycznej jest binarna lub dwumianowa regresja logistyczna, w której zmienna przewidywana lub zależna może mieć tylko 2 możliwe typy, 1 lub 0. Pozwala nam to modelować związek między wieloma zmiennymi predykcyjnymi a binarną / dwumianową zmienną docelową. W przypadku regresji logistycznej funkcja liniowa jest zasadniczo używana jako dane wejściowe do innej funkcji, na przykład w następującej relacji -
$h_{\theta}{(x)}=g(\theta^{T}x)ℎ 0≤h_{\theta}≤1$Oto funkcja logistyczna lub sigmoidalna, którą można podać w następujący sposób:
$g(z)= \frac{1}{1+e^{-z}}ℎ =\theta ^{T}$Do krzywej sigmoidalnej można przedstawić za pomocą poniższego wykresu. Widzimy, że wartości osi Y leżą między 0 a 1 i przecinają oś przy 0,5.
Zajęcia można podzielić na pozytywne lub negatywne. Wynik jest objęty prawdopodobieństwem klasy dodatniej, jeśli mieści się w przedziale od 0 do 1. Dla naszej implementacji interpretujemy wynik funkcji hipotezy jako dodatni, jeśli jest ≥0,5, w przeciwnym razie ujemny.
Musimy również zdefiniować funkcję straty, aby zmierzyć, jak dobrze algorytm działa, używając wag na funkcjach, reprezentowanych przez theta w następujący sposób -
ℎ = ()
$J(\theta) = \frac{1}{m}.(-y^{T}log(h) - (1 -y)^Tlog(1-h))$Teraz, po zdefiniowaniu funkcji straty, naszym głównym celem jest zminimalizowanie funkcji straty. Można to zrobić za pomocą dopasowania ciężarków, czyli zwiększając lub zmniejszając ciężary. Przy pomocy pochodnych funkcji straty dla każdej wagi moglibyśmy wiedzieć, jakie parametry powinny mieć wagę większą, a które mniejszą.
Poniższe równanie gradientu zstępującego mówi nam, jak zmieniłyby się straty, gdybyśmy zmodyfikowali parametry -
$\frac{()}{\theta_{j}}=\frac{1}{m}X^{T}(()−)$Implementacja w Pythonie
Teraz zaimplementujemy powyższą koncepcję dwumianowej regresji logistycznej w Pythonie. W tym celu korzystamy z wielowymiarowego zbioru danych o kwiatach o nazwie „tęczówka”, który ma 3 klasy po 50 instancji każda, ale będziemy używać dwóch pierwszych kolumn cech. Każda klasa reprezentuje rodzaj kwiatu irysa.
Najpierw musimy zaimportować niezbędne biblioteki w następujący sposób -
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasetsNastępnie załaduj zestaw danych tęczówki w następujący sposób -
iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1Możemy wykreślić następujące dane treningowe -
plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();
Następnie zdefiniujemy funkcję sigmoidalną, funkcję straty i zejście gradientu w następujący sposób -
class LogisticRegression:
def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
self.lr = lr
self.num_iter = num_iter
self.fit_intercept = fit_intercept
self.verbose = verbose
def __add_intercept(self, X):
intercept = np.ones((X.shape[0], 1))
return np.concatenate((intercept, X), axis=1)
def __sigmoid(self, z):
return 1 / (1 + np.exp(-z))
def __loss(self, h, y):
return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
def fit(self, X, y):
if self.fit_intercept:
X = self.__add_intercept(X)Teraz zainicjuj wagi w następujący sposób -
self.theta = np.zeros(X.shape[1])
for i in range(self.num_iter):
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
gradient = np.dot(X.T, (h - y)) / y.size
self.theta -= self.lr * gradient
z = np.dot(X, self.theta)
h = self.__sigmoid(z)
loss = self.__loss(h, y)
if(self.verbose ==True and i % 10000 == 0):
print(f'loss: {loss} \t')Przy pomocy następującego skryptu możemy przewidzieć prawdopodobieństwa wyjścia -
def predict_prob(self, X):
if self.fit_intercept:
X = self.__add_intercept(X)
return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
return self.predict_prob(X).round()Następnie możemy ocenić model i wykreślić go w następujący sposób -
model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()
plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');
Wielomianowy model regresji logistycznej
Inną użyteczną formą regresji logistycznej jest wielomianowa regresja logistyczna, w której zmienna docelowa lub zależna może mieć 3 lub więcej możliwych nieuporządkowanych typów, tj. Typów, które nie mają znaczenia ilościowego.
Implementacja w Pythonie
Teraz zaimplementujemy powyższą koncepcję wielomianowej regresji logistycznej w Pythonie. W tym celu używamy zestawu danych ze sklearn o nazwie digit.
Najpierw musimy zaimportować niezbędne biblioteki w następujący sposób -
Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_splitNastępnie musimy załadować cyfrowy zbiór danych -
digits = datasets.load_digits()Teraz zdefiniuj macierz cech (X) i wektor odpowiedzi (y) w następujący sposób -
X = digits.data
y = digits.targetZa pomocą następnej linii kodu możemy podzielić X i Y na zestawy uczące i testowe -
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)Teraz utwórz obiekt regresji logistycznej w następujący sposób -
digreg = linear_model.LogisticRegression()Teraz musimy wytrenować model przy użyciu zestawów uczących w następujący sposób -
digreg.fit(X_train, y_train)Następnie przygotuj prognozy dotyczące zestawu testów w następujący sposób -
y_pred = digreg.predict(X_test)Następnie wydrukuj dokładność modelu w następujący sposób -
print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)Wynik
Accuracy of Logistic Regression model is: 95.6884561891516Z powyższego wyniku wynika, że dokładność naszego modelu wynosi około 96 procent.
Wprowadzenie do SVM
Maszyny wektorów nośnych (SVM) to potężne, ale elastyczne nadzorowane algorytmy uczenia maszynowego, które są używane zarówno do klasyfikacji, jak i regresji. Ale ogólnie są używane w problemach klasyfikacyjnych. W latach 60. po raz pierwszy wprowadzono maszyny SVM, ale później udoskonalono je w 1990 r. Maszyny SVM mają swój unikalny sposób implementacji w porównaniu z innymi algorytmami uczenia maszynowego. Ostatnio są niezwykle popularne ze względu na ich zdolność do obsługi wielu zmiennych ciągłych i kategorialnych.
Działanie SVM
Model SVM jest w zasadzie reprezentacją różnych klas w hiperpłaszczyźnie w przestrzeni wielowymiarowej. Hiperpłaszczyzna zostanie wygenerowana w sposób iteracyjny przez SVM, aby zminimalizować błąd. Celem SVM jest podzielenie zbiorów danych na klasy, aby znaleźć maksymalną marginalną hiperpłaszczyznę (MMH).
Poniżej znajdują się ważne pojęcia w SVM -
Support Vectors- Punkty danych, które są najbliżej hiperpłaszczyzny, nazywane są wektorami nośnymi. Za pomocą tych punktów danych zostanie zdefiniowana linia oddzielająca.
Hyperplane - Jak widać na powyższym diagramie, jest to płaszczyzna decyzyjna lub przestrzeń, która jest podzielona na zbiór obiektów o różnych klasach.
Margin- Można to zdefiniować jako lukę między dwiema liniami w szafowych punktach danych różnych klas. Można ją obliczyć jako prostopadłą odległość od linii do wektorów nośnych. Duży margines jest uważany za dobry, a mały za zły.
Głównym celem SVM jest podzielenie zbiorów danych na klasy, aby znaleźć maksymalną marginalną hiperpłaszczyznę (MMH) i można to zrobić w dwóch następujących krokach -
Po pierwsze, SVM generuje iteracyjnie hiperpłaszczyzny, które w najlepszy sposób segregują klasy.
Następnie wybierze hiperpłaszczyznę, która prawidłowo oddziela klasy.
Wdrażanie SVM w Pythonie
Aby zaimplementować SVM w Pythonie, zaczniemy od importu standardowych bibliotek w następujący sposób -
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns; sns.set()Następnie tworzymy przykładowy zbiór danych, zawierający dane, które można rozdzielić liniowo, ze sklearn.dataset.sample_generator do klasyfikacji za pomocą SVM -
from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=100, centers=2,
random_state=0, cluster_std=0.50)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');Po wygenerowaniu przykładowego zestawu danych zawierającego 100 próbek i 2 klastry otrzymamy wynik:
Wiemy, że SVM obsługuje klasyfikację dyskryminacyjną. oddziela klasy od siebie, po prostu znajdując linię w przypadku dwóch wymiarów lub rozmaitość w przypadku wielu wymiarów. Jest zaimplementowany na powyższym zbiorze danych w następujący sposób -
xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);Dane wyjściowe są następujące -
Z powyższego wyniku widać, że istnieją trzy różne separatory, które doskonale rozróżniają powyższe próbki.
Jak wspomniano, głównym celem SVM jest podzielenie zestawów danych na klasy w celu znalezienia maksymalnej marginalnej hiperpłaszczyzny (MMH), dlatego zamiast rysować linię zerową między klasami, możemy narysować wokół każdej linii margines o pewnej szerokości do najbliższego punktu. Można to zrobić w następujący sposób -
xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
yfit = m * xfit + b
plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);
Na powyższym obrazie wyjściowym możemy łatwo zaobserwować „marginesy” w klasyfikatorach dyskryminacyjnych. SVM wybierze linię, która maksymalizuje margines.
Następnie użyjemy klasyfikatora wektorów pomocniczych Scikit-Learn, aby wytrenować model SVM na tych danych. Tutaj używamy jądra liniowego do dopasowania SVM w następujący sposób -
from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)Dane wyjściowe są następujące -
SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='linear', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)Teraz, dla lepszego zrozumienia, poniżej wykreślimy funkcje decyzyjne dla 2D SVC -
def decision_function(model, ax=None, plot_support=True):
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()Aby ocenić model, musimy utworzyć siatkę w następujący sposób -
x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)Następnie musimy wykreślić granice decyzyjne i marginesy w następujący sposób -
ax.contour(X, Y, P, colors='k',
levels=[-1, 0, 1], alpha=0.5,
linestyles=['--', '-', '--'])Teraz podobnie wykreśl wektory pomocnicze w następujący sposób -
if plot_support:
ax.scatter(model.support_vectors_[:, 0],
model.support_vectors_[:, 1],
s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)Teraz użyj tej funkcji, aby dopasować nasze modele w następujący sposób -
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);
Z powyższego wyniku możemy zauważyć, że klasyfikator SVM dopasowuje się do danych z marginesami, tj. Liniami przerywanymi i wektorami pomocniczymi, czyli kluczowymi elementami tego dopasowania, dotykającymi linii przerywanej. Te punkty wektorów nośnych są przechowywane w atrybucie support_vectors_ klasyfikatora w następujący sposób -
model.support_vectors_Dane wyjściowe są następujące -
array([[0.5323772 , 3.31338909],
[2.11114739, 3.57660449],
[1.46870582, 1.86947425]])Jądra SVM
W praktyce algorytm SVM jest implementowany z jądrem, które przekształca przestrzeń danych wejściowych do wymaganej postaci. SVM wykorzystuje technikę zwaną sztuczką jądra, w której jądro zajmuje mało wymiarową przestrzeń wejściową i przekształca ją w wyższą przestrzeń wymiarową. W prostych słowach, jądro przekształca nierozdzielne problemy w oddzielne problemy, dodając do nich więcej wymiarów. To sprawia, że SVM jest bardziej wydajne, elastyczne i dokładne. Poniżej przedstawiono niektóre typy jąder używanych przez SVM -
Linear Kernel
Może być używany jako iloczyn skalarny między dowolnymi dwoma obserwacjami. Wzór jądra liniowego jest następujący -
k (x, x i ) = suma (x * x i )
Z powyższego wzoru widzimy, że iloczyn między dwoma wektorami mówi & jest sumą mnożenia każdej pary wartości wejściowych.
Jądro wielomianowe
Jest to bardziej uogólniona forma jądra liniowego i rozróżnia zakrzywioną lub nieliniową przestrzeń wejściową. Poniżej znajduje się wzór na jądro wielomianowe -
K (x, xi) = 1 + suma (x * xi) ^ d
Tutaj d jest stopniem wielomianu, który musimy określić ręcznie w algorytmie uczącym.
Kernel Radial Basis Function (RBF)
Jądro RBF, najczęściej używane w klasyfikacji SVM, odwzorowuje przestrzeń wejściową w nieokreślonej przestrzeni wymiarowej. Poniższy wzór wyjaśnia to matematycznie -
K (x, xi) = exp (-gamma * suma ((x - xi ^ 2))
Tutaj gamma waha się od 0 do 1. Musimy ręcznie określić to w algorytmie uczącym. Dobra domyślna wartość gamma to 0,1.
Ponieważ zaimplementowaliśmy SVM dla danych, które można rozdzielić liniowo, możemy zaimplementować je w Pythonie dla danych, których nie można rozdzielić liniowo. Można to zrobić za pomocą jądra.
Przykład
Poniżej znajduje się przykład tworzenia klasyfikatora SVM przy użyciu jądra. Będziemy używać zestawu danych tęczówki ze scikit-learn -
Zaczniemy od importu następujących pakietów -
import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as pltTeraz musimy załadować dane wejściowe -
iris = datasets.load_iris()Z tego zbioru danych bierzemy pierwsze dwie cechy w następujący sposób -
X = iris.data[:, :2]
y = iris.targetNastępnie wykreślimy granice SVM z oryginalnymi danymi w następujący sposób -
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]Teraz musimy podać wartość parametru regularyzacji w następujący sposób -
C = 1.0Następnie można utworzyć obiekt klasyfikatora SVM w następujący sposób -
Svc_classifier = svm.SVC (kernel = 'linear', C = C). Fit (X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with linear kernel')Wynik
Text(0.5, 1.0, 'Support Vector Classifier with linear kernel')
Do tworzenia klasyfikatora SVM z rbf kernel, możemy zmienić jądro na rbf w następujący sposób -
Svc_classifier = svm.SVC(kernel='rbf', gamma =‘auto’,C=C).fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with rbf kernel')Wynik
Text(0.5, 1.0, 'Support Vector Classifier with rbf kernel')
Ustawiamy wartość gamma na „auto”, ale możesz również podać jej wartość z zakresu od 0 do 1.
Plusy i minusy klasyfikatorów SVM
Zalety klasyfikatorów SVM
Klasyfikatory SVM zapewniają dużą dokładność i dobrze współpracują z dużą przestrzenią wymiarową. Klasyfikatory SVM zasadniczo wykorzystują podzbiór punktów szkoleniowych, dlatego w rezultacie zużywają bardzo mniej pamięci.
Wady klasyfikatorów SVM
Mają długi czas szkolenia, dlatego w praktyce nie nadają się do dużych zbiorów danych. Inną wadą jest to, że klasyfikatory SVM nie działają dobrze z nakładającymi się klasami.
Wprowadzenie do drzewa decyzyjnego
Ogólnie rzecz biorąc, analiza drzewa decyzyjnego jest narzędziem do modelowania predykcyjnego, które można zastosować w wielu obszarach. Drzewa decyzyjne mogą być konstruowane za pomocą podejścia algorytmicznego, które może podzielić zbiór danych na różne sposoby w oparciu o różne warunki. Decyzje to najpotężniejsze algorytmy należące do kategorii algorytmów nadzorowanych.
Mogą być używane zarówno do zadań klasyfikacyjnych, jak i regresyjnych. Dwa główne elementy drzewa to węzły decyzyjne, w których dane są dzielone i opuszcza, gdzie otrzymaliśmy wynik. Przykład drzewa binarnego służącego do przewidywania, czy dana osoba jest sprawna, czy niezdolna, podając różne informacje, takie jak wiek, nawyki żywieniowe i nawyki związane z ćwiczeniami, podano poniżej:
W powyższym drzewie decyzyjnym pytaniem są węzły decyzyjne, a ostateczne wyniki to liście. Mamy dwa rodzaje drzew decyzyjnych -
Classification decision trees- W tego rodzaju drzewach decyzyjnych zmienna decyzyjna jest kategoryczna. Powyższe drzewo decyzyjne jest przykładem drzewa decyzyjnego klasyfikacyjnego.
Regression decision trees - W tego rodzaju drzewach decyzyjnych zmienna decyzyjna jest ciągła.
Implementacja algorytmu drzewa decyzyjnego
Indeks Giniego
Jest to nazwa funkcji kosztu, która jest używana do oceny podziałów binarnych w zbiorze danych i współpracuje ze zmienną kategorialną „Sukces” lub „Niepowodzenie”.
Im wyższa wartość indeksu Giniego, tym większa jednorodność. Idealna wartość indeksu Giniego to 0, a najgorsza to 0,5 (dla problemu 2-klasowego). Indeks Giniego dla podziału można obliczyć za pomocą następujących kroków -
Najpierw oblicz indeks Giniego dla węzłów podrzędnych, używając wzoru p ^ 2 + q ^ 2, który jest sumą kwadratu prawdopodobieństwa sukcesu i porażki.
Następnie oblicz wskaźnik Giniego dla podziału, używając ważonego wyniku Giniego każdego węzła tego podziału.
Algorytm drzewa klasyfikacji i regresji (CART) wykorzystuje metodę Giniego do generowania podziałów binarnych.
Podzielone tworzenie
Podział zasadniczo obejmuje atrybut w zbiorze danych i wartość. Możemy utworzyć podział w zbiorze danych za pomocą następujących trzech części -
Part1 - Obliczanie wyniku Giniego: Omówiliśmy tę część w poprzedniej sekcji.
Part2- Dzielenie zbioru danych: można to zdefiniować jako rozdzielenie zbioru danych na dwie listy wierszy posiadających indeks atrybutu i wartość podziału tego atrybutu. Po uzyskaniu dwóch grup - prawej i lewej, ze zbioru danych możemy obliczyć wartość podziału za pomocą wyniku Giniego obliczonego w pierwszej części. Wartość podziału zadecyduje, w której grupie będzie znajdować się atrybut.
Part3- Ocena wszystkich podziałów: Następną częścią po znalezieniu wyniku Giniego i podzieleniu zestawu danych jest ocena wszystkich podziałów. W tym celu najpierw musimy sprawdzić każdą wartość związaną z każdym atrybutem jako kandydujący podział. Następnie musimy znaleźć najlepszy możliwy podział, oceniając koszt podziału. Najlepszy podział zostanie użyty jako węzeł w drzewie decyzyjnym.
Budowanie drzewa
Jak wiemy, drzewo ma węzeł główny i węzły końcowe. Po utworzeniu węzła głównego możemy zbudować drzewo, wykonując dwie części -
Część 1: Tworzenie węzła końcowego
Podczas tworzenia węzłów końcowych drzewa decyzyjnego ważną kwestią jest podjęcie decyzji, kiedy zatrzymać wzrost drzewa lub tworzenie kolejnych węzłów końcowych. Można to zrobić, stosując dwa kryteria, a mianowicie maksymalną głębokość drzewa i minimalne rekordy węzłów w następujący sposób:
Maximum Tree Depth- Jak sama nazwa wskazuje, jest to maksymalna liczba węzłów w drzewie po węźle głównym. Musimy przestać dodawać węzły końcowe, gdy drzewo osiągnie maksymalną głębokość, tj. Gdy drzewo osiągnie maksymalną liczbę węzłów końcowych.
Minimum Node Records- Można go zdefiniować jako minimalną liczbę wzorców treningowych, za które odpowiada dany węzeł. Musimy przestać dodawać węzły końcowe, gdy drzewo osiągnie te minimalne rekordy węzłów lub poniżej tego minimum.
Węzeł końcowy służy do sporządzania ostatecznej prognozy.
Część 2: Dzielenie rekurencyjne
Ponieważ zrozumieliśmy, kiedy tworzyć węzły końcowe, możemy teraz zacząć budować nasze drzewo. Dzielenie rekurencyjne to metoda budowania drzewa. W tej metodzie, po utworzeniu węzła, możemy utworzyć węzły potomne (węzły dodane do istniejącego węzła) rekurencyjnie na każdej grupie danych, generowane przez podzielenie zestawu danych, przez wielokrotne wywoływanie tej samej funkcji.
Prognoza
Po zbudowaniu drzewa decyzyjnego musimy go przewidzieć. Zasadniczo przewidywanie obejmuje nawigację po drzewie decyzyjnym za pomocą specjalnie dostarczonego wiersza danych.
Możemy dokonać prognozy za pomocą funkcji rekurencyjnej, tak jak to zrobiliśmy powyżej. Ta sama procedura przewidywania jest wywoływana ponownie z lewym lub podrzędnym prawym węzłem.
Założenia
Oto niektóre z założeń, jakie przyjmujemy podczas tworzenia drzewa decyzyjnego -
Podczas przygotowywania drzew decyzyjnych zbiór uczący pełni rolę węzła głównego.
Klasyfikator drzewa decyzyjnego preferuje jakościowe wartości cech. W przypadku, gdy chcesz użyć wartości ciągłych, musisz je przeprowadzić dyskretnie przed zbudowaniem modelu.
Na podstawie wartości atrybutu rekordy są rozprowadzane rekurencyjnie.
Podejście statystyczne zostanie użyte do umieszczenia atrybutów w dowolnej pozycji węzła, tj. Jako węzeł główny lub węzeł wewnętrzny.
Implementacja w Pythonie
Przykład
W poniższym przykładzie zamierzamy zaimplementować klasyfikator drzewa decyzyjnego na Pima Indian Diabetes -
Najpierw zacznij od zaimportowania niezbędnych pakietów Pythona -
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_splitNastępnie pobierz zestaw danych tęczówki z łącza internetowego w następujący sposób -
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()pregnant glucose bp skin insulin bmi pedigree age label
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1Teraz podziel zbiór danych na funkcje i zmienną docelową w następujący sposób -
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variableNastępnie podzielimy dane na podział na pociąg i test. Poniższy kod podzieli zbiór danych na 70% danych treningowych i 30% danych testowych -
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)Następnie wytrenuj model za pomocą klasy DecisionTreeClassifier sklearn w następujący sposób -
clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)W końcu musimy przewidzieć. Można to zrobić za pomocą następującego skryptu -
y_pred = clf.predict(X_test)Następnie możemy uzyskać wynik dokładności, macierz pomyłki i raport klasyfikacji w następujący sposób -
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)Wynik
Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
precision recall f1-score support
0 0.72 0.79 0.75 146
1 0.57 0.46 0.51 85
micro avg 0.67 0.67 0.67 231
macro avg 0.64 0.63 0.63 231
weighted avg 0.66 0.67 0.66 231
Accuracy: 0.670995670995671Wizualizacja drzewa decyzyjnego
Powyższe drzewo decyzyjne można zwizualizować za pomocą następującego kodu -
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus
dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
filled=True, rounded=True,
special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('Pima_diabetes_Tree.png')
Image(graph.create_png())
Wprowadzenie do algorytmu Naiwego Bayesa
Naiwne algorytmy Bayesa to technika klasyfikacji oparta na zastosowaniu twierdzenia Bayesa przy silnym założeniu, że wszystkie predyktory są od siebie niezależne. Krótko mówiąc, założenie jest takie, że obecność cechy w klasie jest niezależna od obecności jakiejkolwiek innej cechy w tej samej klasie. Na przykład telefon można uznać za inteligentny, jeśli ma ekran dotykowy, dostęp do Internetu, dobry aparat itp. Chociaż wszystkie te funkcje są od siebie zależne, przyczyniają się one niezależnie do prawdopodobieństwa, że telefon jest smartfonem.
W klasyfikacji bayesowskiej głównym celem jest znalezienie późniejszych prawdopodobieństw, tj. Prawdopodobieństwa etykiety przy pewnych obserwowanych cechach, (|). Za pomocą twierdzenia Bayesa możemy to wyrazić w postaci ilościowej w następujący sposób -
$P(L |features)= \frac{P(L)P(features |L)}{()}$Tutaj (|) jest późniejszym prawdopodobieństwem klasy.
() jest wcześniejszym prawdopodobieństwem klasy.
(|) jest prawdopodobieństwem będącym prawdopodobieństwem predyktora danej klasy.
() jest wcześniejszym prawdopodobieństwem predyktora.
Budowanie modelu przy użyciu Naïve Bayes w Pythonie
Biblioteka Pythona, Scikit Learn jest najbardziej użyteczną biblioteką, która pomaga nam zbudować model Naïve Bayes w Pythonie. Mamy następujące trzy typy modelu Naïve Bayes w bibliotece Scikit Learn Python -
Gaussian Naïve Bayes
Jest to najprostszy klasyfikator Bayesa naiwnego, który zakłada, że dane z każdej etykiety pochodzą z prostego rozkładu Gaussa.
Wielomianowy Naïve Bayes
Innym użytecznym klasyfikatorem Naïve Bayes jest Multinomial Naïve Bayes, w którym zakłada się, że cechy pochodzą z prostego rozkładu wielomianowego. Ten rodzaj Naiwnych Bayesów jest najbardziej odpowiedni dla cech reprezentujących dyskretne liczby.
Bernoulli Naïve Bayes
Innym ważnym modelem jest Bernoulli Naïve Bayes, w którym zakłada się, że cechy są binarne (0 i 1). Klasyfikacja tekstu za pomocą modelu „worka słów” może być zastosowana przez Bernoulliego Naïve Bayesa.
Przykład
W zależności od naszego zbioru danych możemy wybrać dowolny z opisanych powyżej modeli Naïve Bayes. Tutaj wdrażamy model Gaussa Naïve Bayesa w Pythonie -
Zaczniemy od wymaganego importu w następujący sposób -
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()Teraz, używając funkcji make_blobs () funkcji Scikit learn, możemy wygenerować bloby punktów z rozkładem Gaussa w następujący sposób -
from sklearn.datasets import make_blobs
X, y = make_blobs(300, 2, centers=2, random_state=2, cluster_std=1.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');Następnie, aby użyć modelu GaussianNB, musimy zaimportować i utworzyć jego obiekt w następujący sposób -
from sklearn.naive_bayes import GaussianNB
model_GBN = GaussianNB()
model_GNB.fit(X, y);Teraz musimy przewidzieć. Można to zrobić po wygenerowaniu nowych danych w następujący sposób -
rng = np.random.RandomState(0)
Xnew = [-6, -14] + [14, 18] * rng.rand(2000, 2)
ynew = model_GNB.predict(Xnew)Następnie wykreślamy nowe dane, aby znaleźć jego granice -
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='summer', alpha=0.1)
plt.axis(lim);Teraz, za pomocą następującego wiersza kodów, możemy znaleźć późniejsze prawdopodobieństwa pierwszej i drugiej etykiety -
yprob = model_GNB.predict_proba(Xnew)
yprob[-10:].round(3)Wynik
array([[0.998, 0.002],
[1. , 0. ],
[0.987, 0.013],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[1. , 0. ],
[0. , 1. ],
[0.986, 0.014]])Za I przeciw
Plusy
Oto kilka zalet używania klasyfikatorów Naïve Bayes -
Naiwna klasyfikacja Bayesa jest łatwa do wdrożenia i szybka.
Zbiegnie się szybciej niż modele dyskryminacyjne, takie jak regresja logistyczna.
Wymaga mniej danych szkoleniowych.
Charakteryzuje się dużą skalowalnością lub skaluje się liniowo wraz z liczbą predyktorów i punktów danych.
Potrafi przewidywać probabilistyczne i może obsługiwać zarówno dane ciągłe, jak i dyskretne.
Naiwny algorytm klasyfikacji Bayesa może być używany zarówno do binarnych, jak i wieloklasowych problemów klasyfikacji.
Cons
Oto kilka wad używania klasyfikatorów Naïve Bayes -
Jedną z najważniejszych wad klasyfikacji Naïve Bayes jest silna niezależność funkcji, ponieważ w prawdziwym życiu prawie niemożliwe jest posiadanie zestawu funkcji, które są od siebie całkowicie niezależne.
Inną kwestią związaną z klasyfikacją Naïve Bayes jest jej `` częstotliwość zerowa '', co oznacza, że jeśli zmienna kategorialna ma kategorię, ale nie jest obserwowana w zbiorze danych uczących, to model Naïve Bayes przypisze jej zerowe prawdopodobieństwo i nie będzie w stanie utworzyć Prognoza.
Zastosowania klasyfikacji Naïve Bayes
Poniżej przedstawiono niektóre typowe zastosowania klasyfikacji Naïve Bayes -
Real-time prediction - Ze względu na łatwość implementacji i szybkie obliczenia można go używać do prognozowania w czasie rzeczywistym.
Multi-class prediction - Naiwny algorytm klasyfikacji Bayesa może być użyty do przewidywania późniejszego prawdopodobieństwa wielu klas zmiennej docelowej.
Text classification- Ze względu na cechę predykcji wieloklasowej, algorytmy klasyfikacji Naïve Bayes są dobrze przystosowane do klasyfikacji tekstu. Dlatego jest również używany do rozwiązywania problemów, takich jak filtrowanie spamu i analiza opinii.
Recommendation system - Wraz z algorytmami, takimi jak filtrowanie zespołowe, Naïve Bayes tworzy system rekomendacji, który może być używany do filtrowania niewidocznych informacji i przewidywania pogody, którą użytkownik chciałby lub nie.
Wprowadzenie
Losowy las to nadzorowany algorytm uczenia się, który jest używany zarówno do klasyfikacji, jak i regresji. Jednak jest używany głównie do rozwiązywania problemów klasyfikacyjnych. Jak wiemy, las składa się z drzew, a więcej drzew oznacza bardziej wytrzymały las. Podobnie, algorytm losowego lasu tworzy drzewa decyzyjne na próbkach danych, a następnie pobiera prognozę z każdej z nich i ostatecznie wybiera najlepsze rozwiązanie w drodze głosowania. Jest to metoda zespołowa, która jest lepsza niż pojedyncze drzewo decyzyjne, ponieważ zmniejsza nadmierne dopasowanie poprzez uśrednienie wyniku.
Działanie algorytmu losowego lasu
Możemy zrozumieć działanie algorytmu Random Forest za pomocą następujących kroków -
Step1 - Najpierw zacznij od wyboru losowych próbek z danego zbioru danych.
Step2- Następnie algorytm skonstruuje drzewo decyzyjne dla każdej próbki. Wtedy otrzyma wynik prognozy z każdego drzewa decyzyjnego.
Step3 - Na tym etapie głosowanie zostanie przeprowadzone dla każdego przewidywanego wyniku.
Step4 - Na koniec wybierz wynik prognozy z największą liczbą głosów jako ostateczny wynik prognozy.
Poniższy diagram ilustruje jego działanie -
Implementacja w Pythonie
Najpierw zacznij od zaimportowania niezbędnych pakietów Pythona -
import numpy as np
import matplotlib.pyplot as plt
import pandas as pdNastępnie pobierz zestaw danych tęczówki z łącza internetowego w następujący sposób -
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"Następnie musimy przypisać nazwy kolumn do zestawu danych w następujący sposób -
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']Teraz musimy odczytać zbiór danych do pandy dataframe w następujący sposób -
dataset = pd.read_csv(path, names=headernames)
dataset.head()długość działki |
sepal-width |
długość płatka |
szerokość płatka |
Klasa |
|
|---|---|---|---|---|---|
0 |
5.1 |
3.5 |
1.4 |
0,2 |
Iris-setosa |
1 |
4.9 |
3.0 |
1.4 |
0,2 |
Iris-setosa |
2 |
4.7 |
3.2 |
1.3 |
0,2 |
Iris-setosa |
3 |
4.6 |
3.1 |
1.5 |
0,2 |
Iris-setosa |
4 |
5.0 |
3.6 |
1.4 |
0,2 |
Iris-setosa |
Wstępne przetwarzanie danych zostanie wykonane za pomocą następujących wierszy skryptu -
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].valuesNastępnie podzielimy dane na podział na pociąg i test. Poniższy kod podzieli zbiór danych na 70% danych treningowych i 30% danych testowych -
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)Następnie wytrenuj model za pomocą klasy sklearn RandomForestClassifier w następujący sposób -
from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=50)
classifier.fit(X_train, y_train)W końcu musimy przewidzieć. Można to zrobić za pomocą następującego skryptu -
y_pred = classifier.predict(X_test)Następnie wydrukuj wyniki w następujący sposób -
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)Wynik
Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 14
Iris-versicolor 1.00 0.95 0.97 19
Iris-virginica 0.92 1.00 0.96 12
micro avg 0.98 0.98 0.98 45
macro avg 0.97 0.98 0.98 45
weighted avg 0.98 0.98 0.98 45
Accuracy: 0.9777777777777777Plusy i minusy Random Forest
Plusy
Oto zalety algorytmu Random Forest -
Rozwiązuje problem nadmiernego dopasowania poprzez uśrednienie lub połączenie wyników różnych drzew decyzyjnych.
Lasy losowe działają dobrze w przypadku dużego zakresu elementów danych niż pojedyncze drzewo decyzyjne.
Las losowy ma mniej wariancji niż pojedyncze drzewo decyzyjne.
Losowe lasy są bardzo elastyczne i mają bardzo dużą dokładność.
Skalowanie danych nie wymaga algorytmu losowego lasu. Zachowuje dobrą dokładność nawet po dostarczeniu danych bez skalowania.
Skalowanie danych nie wymaga algorytmu losowego lasu. Zachowuje dobrą dokładność nawet po dostarczeniu danych bez skalowania.
Cons
Poniżej przedstawiono wady algorytmu Random Forest -
Złożoność jest główną wadą algorytmów Random Forest.
Budowa lasów losowych jest znacznie trudniejsza i bardziej czasochłonna niż drzew decyzyjnych.
Do zaimplementowania algorytmu Random Forest potrzeba więcej zasobów obliczeniowych.
Jest to mniej intuicyjne w przypadku, gdy mamy duży zbiór drzew decyzyjnych.
Proces przewidywania przy użyciu losowych lasów jest bardzo czasochłonny w porównaniu z innymi algorytmami.
Wprowadzenie do regresji
Regresja to kolejne ważne i szeroko stosowane narzędzie statystyczne i uczenia maszynowego. Głównym celem zadań opartych na regresji jest przewidywanie etykiet wyjściowych lub odpowiedzi, które są ciągłymi wartościami liczbowymi dla danych wejściowych. Wynik będzie oparty na tym, czego model nauczył się w fazie szkolenia. Zasadniczo modele regresji wykorzystują cechy danych wejściowych (zmienne niezależne) i odpowiadające im ciągłe liczbowe wartości wyjściowe (zmienne zależne lub wynikowe), aby nauczyć się określonego związku między danymi wejściowymi a odpowiadającymi im wynikami.
Typy modeli regresji
Istnieją dwa typy modeli regresji -
Simple regression model - Jest to najbardziej podstawowy model regresji, w którym prognozy tworzone są na podstawie pojedynczej, jednoczynnikowej cechy danych.
Multiple regression model - Jak sama nazwa wskazuje, w tym modelu regresji prognozy są tworzone na podstawie wielu cech danych.
Tworzenie regresora w Pythonie
Model regresora w Pythonie można skonstruować tak samo, jak skonstruowaliśmy klasyfikator. Scikit-learn, biblioteka Pythona do uczenia maszynowego, może być również używana do tworzenia regresora w Pythonie.
W poniższym przykładzie będziemy budować podstawowy model regresji, który dopasuje linię do danych, czyli regresor liniowy. Niezbędne kroki do zbudowania regresora w Pythonie są następujące:
Krok 1: Importowanie niezbędnego pakietu Pythona
Aby zbudować regresor za pomocą scikit-learn, musimy go zaimportować wraz z innymi niezbędnymi pakietami. Możemy zaimportować za pomocą następującego skryptu -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as pltKrok 2: Importowanie zbioru danych
Po zaimportowaniu niezbędnego pakietu potrzebujemy zestawu danych do zbudowania modelu predykcyjnego regresji. Możemy zaimportować go z zestawu danych sklearn lub użyć innego, zgodnie z naszymi wymaganiami. Zamierzamy wykorzystać nasze zapisane dane wejściowe. Możemy go zaimportować za pomocą następującego skryptu -
input = r'C:\linear.txt'Następnie musimy załadować te dane. Używamy funkcji np.loadtxt, aby go załadować.
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]Krok 3: Organizowanie danych w zestawy szkoleniowe i testowe
Ponieważ musimy przetestować nasz model na niewidocznych danych, podzielimy nasz zestaw danych na dwie części: zbiór uczący i zbiór testowy. Następujące polecenie wykona to -
training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training
X_train, y_train = X[:training_samples], y[:training_samples]
X_test, y_test = X[training_samples:], y[training_samples:]Krok 4 - Ocena i przewidywanie modelu
Po podzieleniu danych na treningi i testy musimy zbudować model. W tym celu będziemy używać funkcji LineaRegression () programu Scikit-learn. Poniższe polecenie utworzy obiekt regresora liniowego.
reg_linear= linear_model.LinearRegression()Następnie wytrenuj ten model za pomocą próbek szkoleniowych w następujący sposób -
reg_linear.fit(X_train, y_train)Teraz musimy w końcu przeprowadzić prognozę na podstawie danych testowych.
y_test_pred = reg_linear.predict(X_test)Krok 5 - Wykres i wizualizacja
Po prognozowaniu możemy wykreślić i wizualizować to za pomocą następującego skryptu -
plt.scatter(X_test, y_test, color='red')
plt.plot(X_test, y_test_pred, color='black', linewidth=2)
plt.xticks(())
plt.yticks(())
plt.show()Wynik
Na powyższym wyjściu widzimy linię regresji między punktami danych.
Step6- Performance computation - Możemy również obliczyć wydajność naszego modelu regresji za pomocą różnych wskaźników wydajności w następujący sposób -
print("Regressor model performance:")
print("Mean absolute error(MAE) =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error(MSE) =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))Wynik
Regressor model performance:
Mean absolute error(MAE) = 1.78
Mean squared error(MSE) = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09Typy algorytmów regresji ML
Najbardziej użytecznym i popularnym algorytmem regresji ML jest algorytm regresji liniowej, który dalej dzieli się na dwa typy, a mianowicie -
Algorytm prostej regresji liniowej
Algorytm wielokrotnej regresji liniowej.
Omówimy to i zaimplementujemy w Pythonie w następnym rozdziale.
Aplikacje
Zastosowania algorytmów regresji ML są następujące -
Forecasting or Predictive analysis- Jednym z ważnych zastosowań regresji jest prognozowanie lub analiza predykcyjna. Na przykład możemy prognozować PKB, ceny ropy naftowej lub w prostych słowach dane ilościowe, które zmieniają się wraz z upływem czasu.
Optimization- Potrafimy optymalizować procesy biznesowe za pomocą regresji. Na przykład kierownik sklepu może stworzyć model statystyczny, aby zrozumieć, kiedy pojawiają się klienci.
Error correction- W biznesie podjęcie właściwej decyzji jest równie ważne, jak optymalizacja procesu biznesowego. Regresja może nam pomóc w podjęciu właściwej decyzji, jak również w poprawieniu decyzji już wdrożonej.
Economics- To najczęściej używane narzędzie w ekonomii. Możemy użyć regresji do przewidywania podaży, popytu, konsumpcji, inwestycji w zapasy itp.
Finance- Firma finansowa jest zawsze zainteresowana minimalizacją portfela ryzyka i chce poznać czynniki, które mają wpływ na klientów. Wszystko to można przewidzieć za pomocą modelu regresji.
Wprowadzenie do regresji liniowej
Regresję liniową można zdefiniować jako model statystyczny, który analizuje liniową zależność między zmienną zależną a danym zestawem zmiennych niezależnych. Liniowa zależność między zmiennymi oznacza, że gdy zmieni się (wzrośnie lub zmniejszy) wartość jednej lub więcej zmiennych niezależnych, odpowiednio zmieni się również wartość zmiennej zależnej (wzrośnie lub zmniejszy).
Matematycznie zależność można przedstawić za pomocą następującego równania -
Y = mX + b
Tutaj Y jest zmienną zależną, którą próbujemy przewidzieć
X to zmienna zależna, której używamy do prognozowania.
m jest nachyleniem linii regresji, która reprezentuje wpływ X na Y
b jest stałą, znaną jako punkt przecięcia z osią Y. Jeśli X = 0, Y będzie równe b.
Ponadto zależność liniowa może mieć charakter pozytywny lub negatywny, jak wyjaśniono poniżej -
Pozytywna relacja liniowa
Zależność liniowa będzie nazywana dodatnią, jeśli wzrośnie zarówno zmienna niezależna, jak i zależna. Można to zrozumieć za pomocą poniższego wykresu -
Negatywna relacja liniowa
Zależność liniowa będzie nazywana dodatnią, jeśli niezależne wzrosty i zależna zmienna spadną. Można to zrozumieć za pomocą poniższego wykresu -
Rodzaje regresji liniowej
Regresja liniowa ma dwa typy:
Prosta regresja liniowa
Wielokrotna regresja liniowa
Prosta regresja liniowa (SLR)
Jest to najbardziej podstawowa wersja regresji liniowej, która przewiduje odpowiedź przy użyciu pojedynczej cechy. W lustrzankach jednoobiektywowych założenie jest takie, że dwie zmienne są liniowo powiązane.
Implementacja Pythona
Możemy zaimplementować SLR w Pythonie na dwa sposoby, jeden to dostarczenie własnego zbioru danych, a drugi to wykorzystanie zestawu danych z biblioteki scikit-learn python.
Example1 - W poniższym przykładzie implementacji Pythona używamy naszego własnego zbioru danych.
Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -
%matplotlib inline
import numpy as np
import matplotlib.pyplot as pltNastępnie zdefiniuj funkcję, która obliczy ważne wartości dla lustrzanek jednoobiektywowych -
def coef_estimation(x, y):Następująca linia skryptu poda liczbę obserwacji n -
n = np.size(x)Średnią z wektorów xiy można obliczyć w następujący sposób -
m_x, m_y = np.mean(x), np.mean(y)Odchylenie krzyżowe i odchylenie o x możemy znaleźć w następujący sposób -
SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_xNastępnie współczynniki regresji, czyli b, można obliczyć w następujący sposób -
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)Następnie musimy zdefiniować funkcję, która wykreśli linię regresji, a także będzie przewidywać wektor odpowiedzi -
def plot_regression_line(x, y, b):Poniższa linia skryptu przedstawia rzeczywiste punkty jako wykres punktowy -
plt.scatter(x, y, color = "m", marker = "o", s = 30)Następująca linia skryptu przewiduje wektor odpowiedzi -
y_pred = b[0] + b[1]*xNastępujące linie skryptu wykreślą linię regresji i umieszczą na nich etykiety -
plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()Na koniec musimy zdefiniować funkcję main () do dostarczania zestawu danych i wywoływania funkcji, którą zdefiniowaliśmy powyżej -
def main():
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
b = coef_estimation(x, y)
print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
plot_regression_line(x, y, b)
if __name__ == "__main__":
main()Wynik
Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788
Example2 - W poniższym przykładzie implementacji Pythona używamy zestawu danych dotyczących cukrzycy ze scikit-learn.
Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_scoreNastępnie załadujemy zbiór danych dotyczących cukrzycy i utworzymy jego obiekt -
diabetes = datasets.load_diabetes()Ponieważ wdrażamy lustrzankę, będziemy używać tylko jednej funkcji:
X = diabetes.data[:, np.newaxis, 2]Następnie musimy podzielić dane na zestawy uczące i testowe w następujący sposób -
X_train = X[:-30]
X_test = X[-30:]Następnie musimy podzielić cel na zestawy treningowe i testowe w następujący sposób -
y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]Teraz, aby wytrenować model, musimy utworzyć obiekt regresji liniowej w następujący sposób -
regr = linear_model.LinearRegression()Następnie wytrenuj model za pomocą zestawów uczących w następujący sposób -
regr.fit(X_train, y_train)Następnie wykonaj prognozy za pomocą zestawu testowego w następujący sposób -
y_pred = regr.predict(X_test)Następnie wydrukujemy współczynnik, taki jak MSE, wynik wariancji itp. W następujący sposób -
print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f"
% mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))Teraz wykreśl wyniki w następujący sposób -
plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()Wynik
Coefficients:
[941.43097333]
Mean squared error: 3035.06
Variance score: 0.41
Wielokrotna regresja liniowa (MLR)
Jest to rozszerzenie prostej regresji liniowej, która przewiduje odpowiedź przy użyciu dwóch lub więcej cech. Matematycznie możemy to wyjaśnić następująco -
Rozważmy zbiór danych zawierający n obserwacji, p cechy tj. Zmienne niezależne i y jako jedną odpowiedź, tj. Zmienną zależną, linię regresji dla cech p można obliczyć w następujący sposób -
$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}$Tutaj h (x i ) to przewidywana wartość odpowiedzi, a b 0 , b 1 , b 2 â € ¦, b p to współczynniki regresji.
Wiele modeli regresji liniowej zawsze zawiera błędy w danych znane jako błąd resztkowy, który zmienia obliczenia w następujący sposób -
$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}+e_{i}$Możemy również zapisać powyższe równanie w następujący sposób -
$y_{i}=h(x_{i})+e_{i}$ $e_{i}= y_{i} - h(x_{i})$Implementacja Pythona
w tym przykładzie będziemy używać zbioru danych mieszkaniowych w Bostonie ze scikit Learn -
Najpierw zaczniemy od zaimportowania niezbędnych pakietów w następujący sposób -
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metricsNastępnie załaduj zestaw danych w następujący sposób -
boston = datasets.load_boston(return_X_y=False)Poniższe wiersze skryptu definiują macierz cech, X i wektor odpowiedzi, Y -
X = boston.data
y = boston.targetNastępnie podziel zbiór danych na zestawy uczące i testowe w następujący sposób -
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)Teraz utwórz obiekt regresji liniowej i wytrenuj model w następujący sposób -
reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()Wynik
Coefficients:
[-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01]
Variance score: 0.709454060230326
Założenia
Poniżej przedstawiono niektóre założenia dotyczące zbioru danych utworzonego przez model regresji liniowej -
Multi-collinearity- Model regresji liniowej zakłada, że w danych występuje bardzo mała lub żadna współliniowość. Zasadniczo multi-kolinearność występuje, gdy niezależne zmienne lub cechy mają w sobie zależność.
Auto-correlation- Kolejnym założeniem jest to, że model regresji liniowej zakłada, że w danych występuje bardzo mała autokorelacja lub nie ma jej wcale. Zasadniczo autokorelacja występuje, gdy istnieje zależność między błędami resztowymi.
Relationship between variables - Model regresji liniowej zakłada, że związek między odpowiedzią a zmiennymi cech musi być liniowy.
Wprowadzenie do klastrowania
Metody klastrowania są jednymi z najbardziej użytecznych nienadzorowanych metod ML. Metody te służą do znajdowania podobieństw, a także wzorców relacji między próbkami danych, a następnie grupowania tych próbek w grupy o podobieństwie na podstawie cech.
Klastrowanie jest ważne, ponieważ określa wewnętrzne grupowanie wśród obecnie nieoznakowanych danych. Zasadniczo przyjmują pewne założenia dotyczące punktów danych, aby określić ich podobieństwo. Każde założenie skonstruuje różne, ale równie ważne klastry.
Na przykład poniżej znajduje się diagram, który pokazuje system klastrowania pogrupowany razem podobny rodzaj danych w różnych klastrach -
Metody tworzenia klastrów
Nie jest konieczne, aby klastry tworzyły się w formie kulistej. Poniżej znajduje się kilka innych metod tworzenia klastrów -
Oparte na gęstości
W tych metodach klastry są tworzone jako gęsty obszar. Zaletą tych metod jest to, że mają dobrą dokładność, a także dobrą zdolność łączenia dwóch klastrów. Dawny. Przestrzenne grupowanie aplikacji z hałasem w oparciu o gęstość (DBSCAN), punkty zamawiania w celu identyfikacji struktury klastrów (OPTYKA) itp.
Oparty na hierarchii
W tych metodach klastry są tworzone jako struktura drzewiasta oparta na hierarchii. Mają dwie kategorie, a mianowicie aglomeracyjne (podejście oddolne) i dzielące (podejście odgórne). Dawny. Klastrowanie za pomocą reprezentantów (CURE), zrównoważone iteracyjne ograniczanie klastrowania przy użyciu hierarchii (BIRCH) itp.
Partycjonowanie
W tych metodach klastry są tworzone przez podzielenie obiektów na k skupień. Liczba klastrów będzie równa liczbie partycji. Dawny. K-oznacza, grupowanie dużych aplikacji w oparciu o wyszukiwanie losowe (CLARANS).
Krata
W tych metodach klastry są tworzone jako struktura podobna do siatki. Zaletą tych metod jest to, że wszystkie operacje klastrowania wykonywane na tych siatkach są szybkie i niezależne od liczby obiektów danych. Dawny. Siatka informacji statystycznych (STING), Clustering in Quest (CLIQUE).
Pomiar wydajności klastrowania
Jedną z najważniejszych kwestii dotyczących modelu ML jest ocena jego wydajności lub, można powiedzieć, jakość modelu. W przypadku algorytmów uczenia nadzorowanego ocena jakości naszego modelu jest łatwa, ponieważ mamy już etykiety dla każdego przykładu.
Z drugiej strony, w przypadku nienadzorowanych algorytmów uczenia się nie jesteśmy aż tak szczęśliwi, ponieważ mamy do czynienia z nieoznaczonymi danymi. Ale wciąż mamy pewne metryki, które dają praktykowi wgląd w zachodzenie zmian w klastrach w zależności od algorytmu.
Zanim zagłębimy się w takie metryki, musimy zrozumieć, że te metryki tylko oceniają porównawczą wydajność modeli względem siebie, a nie mierzą trafność przewidywań modelu. Poniżej przedstawiono niektóre metryki, które możemy wdrożyć w algorytmach klastrowania w celu pomiaru jakości modelu -
Analiza sylwetki
Analiza sylwetki służy do sprawdzenia jakości modelu skupień poprzez pomiar odległości między skupieniami. Zasadniczo zapewnia nam sposób oceny parametrów, takich jak liczba klastrów za pomocąSilhouette score. Wynik ten mierzy, jak blisko każdego punktu w jednym klastrze znajduje się punkt w sąsiednich klastrach.
Analiza wyniku sylwetki
Zakres punktacji Silhouette to [-1, 1]. Jego analiza jest następująca -
+1 Score - Blisko +1 Silhouette score wskazuje, że próbka jest daleko od sąsiedniego skupienia.
0 Score - 0 Silhouette score wskazuje, że próbka znajduje się na granicy decyzyjnej oddzielającej dwa sąsiednie klastry lub bardzo blisko niej.
-1 Score & minusl -1 Silhouette score wskazuje, że próbki zostały przypisane do niewłaściwych klastrów.
Obliczenie wyniku Silhouette można wykonać za pomocą następującego wzoru -
= (-) / (,)
Tutaj = średnia odległość do punktów w najbliższym klastrze
I = średnia odległość wewnątrz klastra do wszystkich punktów.
Indeks Davisa-Bouldina
Indeks bazy danych to kolejna dobra miara do przeprowadzania analizy algorytmów klastrowania. Za pomocą indeksu DB możemy zrozumieć następujące punkty dotyczące modelu grupowania -
Czy gromady są dobrze oddalone od siebie, czy nie?
Jak gęste są klastry?
Możemy obliczyć indeks DB za pomocą następującego wzoru -
$DB=\frac{1}{n}\displaystyle\sum\limits_{i=1}^n max_{j\neq{i}}\left(\frac{\sigma_{i}+\sigma_{j}}{d(c_{i},c_{j})}\right)$Tutaj = liczba klastrów
σ i = średnia odległość wszystkich punktów w klastrze od środka ciężkości gromady.
Im mniej indeksu DB, tym lepszy jest model klastrowy.
Dunn Index
Działa tak samo jak indeks DB, ale są następujące punkty, w których oba się różnią -
Indeks Dunna bierze pod uwagę tylko najgorszy przypadek, tj. Klastry, które są blisko siebie, podczas gdy indeks DB bierze pod uwagę rozproszenie i separację wszystkich klastrów w modelu skupień.
Indeks Dunn rośnie wraz ze wzrostem wydajności, podczas gdy indeks DB staje się lepszy, gdy klastry są dobrze rozmieszczone i gęste.
Możemy obliczyć indeks Dunna za pomocą następującego wzoru -
$D=\frac{min_{1\leq i <{j}\leq{n}}P(i,j)}{mix_{1\leq i < k \leq n}q(k)}$Tutaj ,, = każdy indeks dla klastrów
= odległość między klastrami
q = odległość wewnątrz klastra
Typy algorytmów klastrowania ML
Poniżej przedstawiono najważniejsze i przydatne algorytmy klastrowania ML -
Grupowanie środków K
Ten algorytm grupowania oblicza centroidy i wykonuje iteracje, aż znajdziemy optymalną centroidę. Zakłada, że liczba klastrów jest już znana. Jest również nazywany algorytmem płaskiego klastrowania. Liczba klastrów zidentyfikowanych na podstawie danych za pomocą algorytmu jest reprezentowana przez „K” w K-średnich.
Algorytm zmiany średniej
Jest to kolejny potężny algorytm klastrowania używany w uczeniu się bez nadzoru. W przeciwieństwie do grupowania K-średnich nie przyjmuje żadnych założeń, dlatego jest to algorytm nieparametryczny.
Klastrowanie hierarchiczne
Jest to kolejny nienadzorowany algorytm uczenia się, który jest używany do grupowania nieoznaczonych punktów danych o podobnych cechach.
W następnych rozdziałach szczegółowo omówimy wszystkie te algorytmy.
Zastosowania klastrowania
Klastrowanie może być przydatne w następujących obszarach -
Data summarization and compression- Klastrowanie jest szeroko stosowane w obszarach, w których potrzebujemy podsumowania, kompresji i redukcji danych. Przykładami są przetwarzanie obrazu i kwantyzacja wektorowa.
Collaborative systems and customer segmentation - Ponieważ tworzenie klastrów może być wykorzystywane do wyszukiwania podobnych produktów lub tego samego rodzaju użytkowników, można je stosować w obszarze systemów współpracy i segmentacji klientów.
Serve as a key intermediate step for other data mining tasks- Analiza skupień może wygenerować zwięzłe podsumowanie danych do klasyfikacji, testowania, generowania hipotez; w związku z tym służy jako kluczowy etap pośredni również dla innych zadań eksploracji danych.
Trend detection in dynamic data - Klastrowanie może być również wykorzystywane do wykrywania trendów w danych dynamicznych poprzez tworzenie różnych klastrów podobnych trendów.
Social network analysis- Klastrowanie może być używane w analizie sieci społecznościowych. Przykładami są generowanie sekwencji w obrazach, filmach lub audio.
Biological data analysis - Klastrowanie może być również używane do tworzenia klastrów obrazów, filmów, dzięki czemu może być z powodzeniem wykorzystywane w analizie danych biologicznych.
Wprowadzenie do algorytmu K-średnich
Algorytm grupowania K-średnich oblicza centroidy i wykonuje iteracje, aż znajdziemy optymalną centroidę. Zakłada, że liczba klastrów jest już znana. Nazywa się to równieżflat clusteringalgorytm. Liczba klastrów zidentyfikowanych na podstawie danych za pomocą algorytmu jest reprezentowana przez „K” w K-średnich.
W tym algorytmie punkty danych są przypisywane do klastra w taki sposób, że suma kwadratu odległości między punktami danych i centroidą byłaby minimalna. Należy rozumieć, że mniejsza zmienność w obrębie klastrów doprowadzi do większej liczby podobnych punktów danych w tym samym klastrze.
Działanie algorytmu K-średnich
Możemy zrozumieć działanie algorytmu grupowania K-średnich za pomocą następujących kroków -
Step1 - Najpierw musimy określić liczbę klastrów, K, które mają zostać wygenerowane przez ten algorytm.
Step2- Następnie losowo wybierz K punktów danych i przypisz każdy punkt danych do klastra. W prostych słowach sklasyfikuj dane na podstawie liczby punktów danych.
Step3 - Teraz obliczy centroidy klastra.
Step4 - Następnie kontynuuj iterację, aż znajdziemy optymalną centroidę, czyli przypisanie punktów danych do klastrów, które już się nie zmieniają -
4.1 - Najpierw zostanie obliczona suma kwadratów odległości między punktami danych i centroidami.
4.2 - Teraz musimy przypisać każdy punkt danych do klastra, który jest bliżej niż inny klaster (centroid).
4.3 - Na koniec obliczyć centroidy dla klastrów, biorąc średnią ze wszystkich punktów danych tego klastra.
K-oznacza następuje Expectation-Maximizationpodejście do rozwiązania problemu. Krok oczekiwania jest używany do przypisywania punktów danych do najbliższego klastra, a krok maksymalizacji jest używany do obliczania centroidu każdego klastra.
Pracując z algorytmem K-średnich musimy zadbać o następujące rzeczy -
Podczas pracy z algorytmami grupowania, w tym K-Means, zaleca się standaryzację danych, ponieważ takie algorytmy wykorzystują pomiar na podstawie odległości do określenia podobieństwa między punktami danych.
Ze względu na iteracyjną naturę K-średnich i losową inicjalizację centroidów, K-średnie mogą trzymać się lokalnego optimum i mogą nie zbiegać się do global optimum. Dlatego zaleca się stosowanie różnych inicjalizacji centroidów.
Implementacja w Pythonie
Poniższe dwa przykłady implementacji algorytmu klastrowania K-Means pomogą nam w jego lepszym zrozumieniu -
Przykład 1
To prosty przykład, aby zrozumieć, jak działa k-średnich. W tym przykładzie najpierw wygenerujemy zestaw danych 2D zawierający 4 różne obiekty blob, a następnie zastosujemy algorytm k-średnich, aby zobaczyć wynik.
Najpierw zaczniemy od zaimportowania niezbędnych pakietów -
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeansPoniższy kod wygeneruje 2D, zawierający cztery obiekty blob -
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)Następnie poniższy kod pomoże nam zwizualizować zbiór danych -
plt.scatter(X[:, 0], X[:, 1], s=20);
plt.show()
Następnie utwórz obiekt KMeans wraz z podaniem liczby klastrów, wytrenuj model i wykonaj prognozę w następujący sposób -
kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)Teraz za pomocą następującego kodu możemy wykreślić i wizualizować centra klastra wybrane przez estymator Pythona k-średnich -
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()
Przykład 2
Przejdźmy do innego przykładu, w którym zastosujemy grupowanie K-średnich na zbiorze danych zawierających proste cyfry. K-średnich spróbuje zidentyfikować podobne cyfry bez korzystania z oryginalnych informacji na etykiecie.
Najpierw zaczniemy od zaimportowania niezbędnych pakietów -
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeansNastępnie załaduj cyfrowy zestaw danych ze sklearn i utwórz z niego obiekt. Możemy również znaleźć liczbę wierszy i kolumn w tym zbiorze danych w następujący sposób -
from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shapeWynik
(1797, 64)Powyższe dane wyjściowe pokazują, że ten zestaw danych zawiera 1797 próbek z 64 funkcjami.
Możemy przeprowadzić grupowanie, tak jak w przykładzie 1 powyżej -
kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shapeWynik
(10, 64)Powyższe dane wyjściowe pokazują, że K-średnie utworzyły 10 klastrów z 64 cechami.
fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
axi.set(xticks=[], yticks=[])
axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)Wynik
Jako wynik otrzymamy następujący obraz przedstawiający centra klastrów wyuczone za pomocą k-średnich.
Następujące wiersze kodu będą dopasowywać wyuczone etykiety klastrów do prawdziwych etykiet w nich znalezionych -
from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
mask = (clusters == i)
labels[mask] = mode(digits.target[mask])[0]Następnie możemy sprawdzić dokładność w następujący sposób -
from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)Wynik
0.7935447968836951Powyższe dane wyjściowe pokazują, że dokładność wynosi około 80%.
Zalety i wady
Zalety
Poniżej przedstawiono niektóre zalety algorytmów klastrowania K-średnich -
Jest bardzo łatwy do zrozumienia i wdrożenia.
Gdybyśmy mieli wtedy dużą liczbę zmiennych, K-średnie byłyby szybsze niż grupowanie hierarchiczne.
Po ponownym obliczeniu centroid instancja może zmienić klaster.
Węższe klastry są tworzone za pomocą K-średnich w porównaniu z grupowaniem hierarchicznym.
Niedogodności
Poniżej przedstawiono niektóre wady algorytmów klastrowania K-średnich -
Nieco trudno jest przewidzieć liczbę klastrów, czyli wartość k.
Na wynik silnie wpływają początkowe dane wejściowe, takie jak liczba klastrów (wartość k).
Kolejność danych będzie miała duży wpływ na ostateczny wynik.
Jest bardzo wrażliwy na przeskalowanie. Jeśli przeskalujemy nasze dane za pomocą normalizacji lub standaryzacji, wynik całkowicie się zmieni.
Nie jest dobrze wykonywać zadanie grupowania, jeśli klastry mają skomplikowany kształt geometryczny.
Zastosowania algorytmu grupowania metodą k-średnich
Główne cele analizy skupień to -
Aby uzyskać sensowną intuicję z danych, z którymi pracujemy.
Następnie przewiduj klastry, gdzie będą budowane różne modele dla różnych podgrup.
Aby zrealizować powyższe cele, klastrowanie K-średnich działa wystarczająco dobrze. Może być używany w następujących aplikacjach -
Segmentacja rynku
Grupowanie dokumentów
Segmentacja obrazu
Kompresja obrazu
Segmentacja klientów
Analiza trendu na danych dynamicznych
Wprowadzenie do algorytmu zmiany średniej
Jak wspomniano wcześniej, jest to kolejny potężny algorytm klastrowania używany w uczeniu się bez nadzoru. W przeciwieństwie do grupowania K-średnich, nie przyjmuje żadnych założeń; stąd jest to algorytm nieparametryczny.
Algorytm zmiany średniej zasadniczo przypisuje punkty danych do klastrów iteracyjnie, przesuwając punkty w kierunku największej gęstości punktów danych, tj. Środka ciężkości klastra.
Różnica między algorytmem K-Means a Mean-Shift polega na tym, że później nie ma potrzeby wcześniejszego określania liczby klastrów, ponieważ liczba klastrów zostanie określona przez algorytm wrt data.
Działanie algorytmu zmiany średniej
Możemy zrozumieć działanie algorytmu grupowania średniej zmiany za pomocą następujących kroków -
Step1 - Najpierw zacznij od punktów danych przypisanych do własnego klastra.
Step2 - Następnie ten algorytm obliczy centroidy.
Step3 - Na tym etapie zostanie zaktualizowana lokalizacja nowych centroidów.
Step4 - Teraz proces zostanie powtórzony i przeniesiony do regionu o wyższej gęstości.
Step5 - W końcu zostanie zatrzymany, gdy centroidy osiągną pozycję, z której nie mogą się dalej poruszać.
Implementacja w Pythonie
To prosty przykład, aby zrozumieć, jak działa algorytm zmiany średniej. W tym przykładzie najpierw wygenerujemy zestaw danych 2D zawierający 4 różne obiekty blob, a następnie zastosujemy algorytm zmiany średniej, aby zobaczyć wynik.
%matplotlib inline
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.datasets.samples_generator import make_blobs
centers = [[3,3,3],[4,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 700, centers = centers, cluster_std = 0.5)
plt.scatter(X[:,0],X[:,1])
plt.show()
ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 3)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
marker=".",color='k', s=20, linewidths = 5, zorder=10)
plt.show()Wynik
[[ 2.98462798 9.9733794 10.02629344]
[ 3.94758484 4.99122771 4.99349433]
[ 3.00788996 3.03851268 2.99183033]]
Estimated clusters: 3
Zalety i wady
Zalety
Oto niektóre zalety algorytmu grupowania ze zmianą średniej -
Nie trzeba robić żadnych założeń modelowych, jak w przypadku średnich K lub mieszaniny Gaussa.
Może także modelować złożone skupiska, które mają nieprzekraczalny kształt.
Potrzebuje tylko jednego parametru o nazwie przepustowość, który automatycznie określa liczbę klastrów.
Nie ma kwestii lokalnych minimów, jak w przypadku K-średnich.
Nie ma problemu związanego z wartościami odstającymi.
Niedogodności
Poniżej przedstawiono niektóre wady algorytmu grupowania z przesunięciem średniej -
Algorytm zmiany średniej nie działa dobrze w przypadku dużego wymiaru, gdzie liczba klastrów gwałtownie się zmienia.
Nie mamy bezpośredniej kontroli nad liczbą klastrów, ale w niektórych aplikacjach potrzebujemy określonej liczby klastrów.
Nie potrafi odróżnić trybów znaczących i pozbawionych znaczenia.
Wprowadzenie do klastrowania hierarchicznego
Klastrowanie hierarchiczne to kolejny nienadzorowany algorytm uczenia się, który jest używany do grupowania nieoznakowanych punktów danych o podobnych cechach. Hierarchiczne algorytmy grupowania dzielą się na dwie kategorie -
Agglomerative hierarchical algorithms- W aglomeracyjnych algorytmach hierarchicznych każdy punkt danych jest traktowany jako pojedynczy klaster, a następnie kolejno łączy lub aglomeruje (podejście oddolne) pary klastrów. Hierarchia klastrów jest reprezentowana jako dendrogram lub struktura drzewiasta.
Divisive hierarchical algorithms - Z drugiej strony, w algorytmach hierarchicznych z podziałem, wszystkie punkty danych są traktowane jako jeden duży klaster, a proces grupowania polega na podzieleniu (podejście odgórne) jednego dużego klastra na różne małe klastry.
Kroki prowadzące do aglomeracyjnego klastrowania hierarchicznego
Wyjaśnimy najczęściej używane i najważniejsze klastry hierarchiczne, tj. Aglomeracyjne. Kroki, aby wykonać to samo, są następujące -
Step1- Traktuj każdy punkt danych jako pojedynczy klaster. Dlatego na początku będziemy mieć, powiedzmy, klastry K. Liczba punktów danych będzie również wynosić K. na początku.
Step2- Teraz na tym etapie musimy utworzyć duży klaster, łącząc dwa punkty danych szafy. Spowoduje to w sumie klastry K-1.
Step3- Teraz, aby utworzyć więcej klastrów, musimy połączyć dwa klastry zamknięte. Spowoduje to w sumie klastry K-2.
Step4 - Teraz, aby utworzyć jeden duży klaster, powtórz powyższe trzy kroki, aż K stanie się 0, czyli nie ma więcej punktów danych do połączenia.
Step5 - W końcu, po utworzeniu jednego dużego klastra, dendrogramy zostaną użyte do podzielenia na wiele klastrów w zależności od problemu.
Rola dendrogramów w aglomeracyjnym klastrowaniu hierarchicznym
Jak omówiliśmy w ostatnim kroku, rola dendrogramu zaczyna się po utworzeniu dużego klastra. Dendrogram zostanie użyty do podzielenia klastrów na wiele klastrów powiązanych punktów danych w zależności od naszego problemu. Można to zrozumieć za pomocą następującego przykładu -
Przykład 1
Aby to zrozumieć, zacznijmy od zaimportowania wymaganych bibliotek w następujący sposób -
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as npNastępnie będziemy wykreślać punkty danych, które wzięliśmy dla tego przykładu -
X = np.array([[7,8],[12,20],[17,19],[26,15],[32,37],[87,75],[73,85], [62,80],[73,60],[87,96],])
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
plt.annotate(label,xy=(x, y), xytext=(-3, 3),textcoords='offset points', ha='right', va='bottom')
plt.show()
Z powyższego diagramu bardzo łatwo można zobaczyć, że w naszych punktach danych mamy dwie klastry, ale w rzeczywistych danych mogą istnieć tysiące klastrów. Następnie będziemy rysować dendrogramy naszych punktów danych za pomocą biblioteki Scipy -
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked, orientation='top',labels=labelList, distance_sort='descending',show_leaf_counts=True)
plt.show()
Teraz, po utworzeniu dużej gromady, wybierana jest najdłuższa odległość w pionie. Następnie przechodzi przez nią pionowa linia, jak pokazano na poniższym schemacie. Gdy pozioma linia przecina niebieską linię w dwóch punktach, liczba klastrów wynosiłaby dwa.
Następnie musimy zaimportować klasę do klastrowania i wywołać jej metodę fit_predict, aby przewidzieć klaster. Importujemy klasę AgglomerativeClustering biblioteki sklearn.cluster -
from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
cluster.fit_predict(X)Następnie wykreśl klaster za pomocą następującego kodu -
plt.scatter(X[:,0],X[:,1], c=cluster.labels_, cmap='rainbow')
Powyższy diagram przedstawia dwie grupy z naszych punktów danych.
Przykład 2
Ponieważ zrozumieliśmy koncepcję dendrogramów z prostego przykładu omówionego powyżej, przejdźmy do innego przykładu, w którym tworzymy klastry punktu danych w zestawie danych Pima Indian Diabetes Dataset za pomocą hierarchicznego grupowania -
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
data.shape
(768, 9)
data.head()| slno. | preg | Plas | Pres | skóra | test | masa | pedi | wiek | klasa |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 6 | 148 | 72 | 35 | 0 | 33.6 | 0.627 | 50 | 1 |
| 1 | 1 | 85 | 66 | 29 | 0 | 26.6 | 0,351 | 31 | 0 |
| 2 | 8 | 183 | 64 | 0 | 0 | 23.3 | 0.672 | 32 | 1 |
| 3 | 1 | 89 | 66 | 23 | 94 | 28.1 | 0,167 | 21 | 0 |
| 4 | 0 | 137 | 40 | 35 | 168 | 43.1 | 2.288 | 33 | 1 |
patient_data = data.iloc[:, 3:5].values
import scipy.cluster.hierarchy as shc
plt.figure(figsize=(10, 7))
plt.title("Patient Dendograms")
dend = shc.dendrogram(shc.linkage(data, method='ward'))
from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
cluster.fit_predict(patient_data)
plt.figure(figsize=(10, 7))
plt.scatter(patient_data[:,0], patient_data[:,1], c=cluster.labels_, cmap='rainbow')
Wprowadzenie
Algorytm K-najbliższych sąsiadów (KNN) jest rodzajem nadzorowanego algorytmu ML, który może być stosowany zarówno do klasyfikacji, jak i problemów predykcyjnych regresji. Jednak jest używany głównie do klasyfikacji problemów predykcyjnych w przemyśle. Następujące dwie właściwości dobrze definiują KNN -
Lazy learning algorithm - KNN jest algorytmem leniwego uczenia się, ponieważ nie ma wyspecjalizowanej fazy szkolenia i wykorzystuje wszystkie dane do uczenia podczas klasyfikacji.
Non-parametric learning algorithm - KNN jest również nieparametrycznym algorytmem uczenia się, ponieważ nie zakłada niczego na temat podstawowych danych.
Działanie algorytmu KNN
Algorytm K-najbliższych sąsiadów (KNN) wykorzystuje „podobieństwo cech” do przewidywania wartości nowych punktów danych, co ponadto oznacza, że nowemu punktowi danych zostanie przypisana wartość na podstawie tego, jak dokładnie pasuje do punktów w zestawie uczącym. Możemy zrozumieć jego działanie za pomocą następujących kroków -
Step1- Do implementacji dowolnego algorytmu potrzebujemy zbioru danych. Dlatego w pierwszym etapie KNN musimy załadować dane treningowe i testowe.
Step2- Następnie musimy wybrać wartość K, czyli najbliższe punkty danych. K może być dowolną liczbą całkowitą.
Step3 - Dla każdego punktu w danych testowych wykonaj następujące czynności -
3.1- Oblicz odległość między danymi testowymi a każdym wierszem danych treningowych za pomocą dowolnej metody, a mianowicie: odległość euklidesowa, manhattańska lub Hamminga. Najczęściej stosowaną metodą obliczania odległości jest metoda euklidesowa.
3.2 - Teraz, na podstawie wartości odległości, posortuj je w kolejności rosnącej.
3.3 - Następnie wybierze K górnych wierszy z posortowanej tablicy.
3.4 - Teraz przypisze klasę do punktu testowego na podstawie najczęstszych klas tych wierszy.
Step4 - Koniec
Przykład
Poniżej znajduje się przykład zrozumienia pojęcia K i działania algorytmu KNN -
Załóżmy, że mamy zbiór danych, który można wykreślić w następujący sposób:
Teraz musimy zaklasyfikować nowy punkt danych z czarną kropką (w punkcie 60,60) do klasy niebieskiej lub czerwonej. Zakładamy, że K = 3, czyli znajdzie trzy najbliższe punkty danych. Jest to pokazane na następnym schemacie -
Na powyższym diagramie widzimy trzy najbliższe sąsiedzi punktu danych z czarną kropką. Spośród tych trzech, dwa z nich należą do klasy czerwonej, stąd czarna kropka zostanie również przypisana do klasy czerwonej.
Implementacja w Pythonie
Jak wiemy, algorytm K-najbliższych sąsiadów (KNN) może być stosowany zarówno do klasyfikacji, jak i do regresji. Poniżej znajdują się przepisy w Pythonie na użycie KNN jako klasyfikatora, a także regresora -
KNN jako klasyfikator
Najpierw zacznij od zaimportowania niezbędnych pakietów Pythona -
import numpy as np
import matplotlib.pyplot as plt
import pandas as pdNastępnie pobierz zestaw danych tęczówki z łącza internetowego w następujący sposób -
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"Następnie musimy przypisać nazwy kolumn do zestawu danych w następujący sposób -
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']Teraz musimy odczytać zbiór danych do pandy dataframe w następujący sposób -
dataset = pd.read_csv(path, names=headernames)
dataset.head()| slno. | długość działki | sepal-width | długość płatka | szerokość płatka | Klasa |
|---|---|---|---|---|---|
| 0 | 5.1 | 3.5 | 1.4 | 0,2 | Iris-setosa |
| 1 | 4.9 | 3.0 | 1.4 | 0,2 | Iris-setosa |
| 2 | 4.7 | 3.2 | 1.3 | 0,2 | Iris-setosa |
| 3 | 4.6 | 3.1 | 1.5 | 0,2 | Iris-setosa |
| 4 | 5.0 | 3.6 | 1.4 | 0,2 | Iris-setosa |
Wstępne przetwarzanie danych zostanie wykonane za pomocą następujących wierszy skryptu -
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].valuesNastępnie podzielimy dane na podział na pociąg i test. Poniższy kod podzieli zbiór danych na 60% danych szkoleniowych i 40% danych testowych -
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)Następnie skalowanie danych zostanie wykonane w następujący sposób -
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)Następnie wytrenuj model za pomocą klasy sklearn KNeighborsClassifier w następujący sposób -
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=8)
classifier.fit(X_train, y_train)W końcu musimy przewidzieć. Można to zrobić za pomocą następującego skryptu -
y_pred = classifier.predict(X_test)Następnie wydrukuj wyniki w następujący sposób -
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)Wynik
Confusion Matrix:
[[21 0 0]
[ 0 16 0]
[ 0 7 16]]
Classification Report:
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 21
Iris-versicolor 0.70 1.00 0.82 16
Iris-virginica 1.00 0.70 0.82 23
micro avg 0.88 0.88 0.88 60
macro avg 0.90 0.90 0.88 60
weighted avg 0.92 0.88 0.88 60
Accuracy: 0.8833333333333333KNN jako regresor
Najpierw zacznij od zaimportowania niezbędnych pakietów Pythona -
import numpy as np
import pandas as pdNastępnie pobierz zestaw danych tęczówki z łącza internetowego w następujący sposób -
path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"Następnie musimy przypisać nazwy kolumn do zestawu danych w następujący sposób -
headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']Teraz musimy odczytać zbiór danych do pandy dataframe w następujący sposób -
data = pd.read_csv(url, names=headernames)
array = data.values
X = array[:,:2]
Y = array[:,2]
data.shape
output:(150, 5)Następnie zaimportuj KNeighborsRegressor ze sklearn, aby dopasować model -
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=10)
knnr.fit(X, y)W końcu możemy znaleźć MSE w następujący sposób -
print ("The MSE is:",format(np.power(y-knnr.predict(X),2).mean()))Wynik
The MSE is: 0.12226666666666669Plusy i minusy KNN
Plusy
Jest to bardzo prosty algorytm do zrozumienia i zinterpretowania.
Jest to bardzo przydatne w przypadku danych nieliniowych, ponieważ nie ma założeń dotyczących danych w tym algorytmie.
Jest to wszechstronny algorytm, ponieważ możemy go używać zarówno do klasyfikacji, jak i regresji.
Ma stosunkowo wysoką dokładność, ale istnieją znacznie lepsze nadzorowane modele uczenia się niż KNN.
Cons
Jest to algorytm nieco kosztowny obliczeniowo, ponieważ przechowuje wszystkie dane szkoleniowe.
Wymagana duża ilość pamięci w porównaniu do innych algorytmów uczenia nadzorowanego.
Przewidywanie jest powolne w przypadku dużego N.
Jest bardzo wrażliwy na skalę danych i nieistotne cechy.
Zastosowania KNN
Oto niektóre z obszarów, w których można z powodzeniem zastosować KNN -
System bankowy
KNN może być używany w systemie bankowym do przewidywania, czy dana osoba jest zdolna do zatwierdzenia kredytu? Czy ta osoba ma cechy podobne do tych, którzy upadli?
Obliczanie ratingów kredytowych
Algorytmy KNN można wykorzystać do ustalenia ratingu kredytowego danej osoby poprzez porównanie z osobami o podobnych cechach.
Polityka
Za pomocą algorytmów KNN możemy zaklasyfikować potencjalnego wyborcę do różnych klas, takich jak „Będzie głosować”, „Nie będzie głosować”, „Zagłosuje na kongres partii”, „Zagłosuje na„ BJP ”partii.
Inne obszary, w których można zastosować algorytm KNN, to Rozpoznawanie mowy, Wykrywanie pisma ręcznego, Rozpoznawanie obrazu i Rozpoznawanie wideo.
Istnieją różne metryki, których możemy użyć do oceny wydajności algorytmów ML, klasyfikacji oraz algorytmów regresji. Musimy uważnie wybrać metryki do oceny wydajności ML, ponieważ -
Sposób mierzenia i porównywania wydajności algorytmów ML będzie całkowicie zależał od wybranej metryki.
To, jak zważycie znaczenie różnych cech w wyniku, będzie całkowicie zależało od wybranej metryki.
Wskaźniki wydajności dla problemów klasyfikacyjnych
Omówiliśmy klasyfikację i jej algorytmy w poprzednich rozdziałach. Tutaj omówimy różne metryki wydajności, których można użyć do oceny prognoz dotyczących problemów klasyfikacyjnych.
Macierz zamieszania
Jest to najłatwiejszy sposób pomiaru wydajności problemu klasyfikacji, w którym wynik może składać się z dwóch lub więcej typów klas. Macierz zamieszania to nic innego jak stół o dwóch wymiarach, a mianowicie. „Rzeczywiste” i „Przewidywane”, a ponadto oba wymiary mają „Prawdziwie pozytywne (TP)”, „Prawdziwie negatywne (TN)”, „Fałszywie dodatnie (FP)”, „Fałszywie negatywne (FN)”, jak pokazano poniżej -
Wyjaśnienie terminów związanych z matrycą nieporozumień jest następujące -
True Positives (TP) - Dzieje się tak, gdy zarówno aktualna klasa, jak i przewidywana klasa punktu danych to 1.
True Negatives (TN) - Dzieje się tak, gdy zarówno aktualna klasa, jak i przewidywana klasa punktu danych mają wartość 0.
False Positives (FP) - Tak jest w przypadku, gdy aktualna klasa punktu danych to 0, a przewidywana klasa punktu danych to 1.
False Negatives (FN) - Tak jest w przypadku, gdy aktualna klasa punktu danych to 1, a przewidywana klasa punktu danych to 0.
Możemy użyć funkcji confusion_matrix sklearn.metrics do obliczenia macierzy konfuzji naszego modelu klasyfikacji.
Dokładność klasyfikacji
Jest to najczęściej stosowany wskaźnik wydajności algorytmów klasyfikacyjnych. Można go zdefiniować jako liczbę prawidłowych prognoz jako stosunek wszystkich dokonanych prognoz. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$Accuracy =\frac{TP+TN}{+++}$Aby obliczyć dokładność naszego modelu klasyfikacji, możemy użyć funkcji dokładności_score sklearn.metrics.
Raport klasyfikacyjny
Ten raport składa się z wyników Precision, Recall, F1 i Support. Są one wyjaśnione w następujący sposób -
Precyzja
Precyzja wykorzystywana przy pobieraniu dokumentów może być zdefiniowana jako liczba poprawnych dokumentów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$Precision=\frac{TP}{TP+FP}$Przypomnienie lub wrażliwość
Recall można zdefiniować jako liczbę pozytywów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$Recall =\frac{TP}{TP+FN}$Specyficzność
Specyficzność, w przeciwieństwie do przypominania, można zdefiniować jako liczbę negatywów zwróconych przez nasz model ML. Możemy go łatwo obliczyć za pomocą macierzy pomyłki za pomocą następującego wzoru -
$Specificity =\frac{TN}{TN+FP}$Wsparcie
Wsparcie można zdefiniować jako liczbę próbek prawdziwej odpowiedzi, która znajduje się w każdej klasie wartości docelowych.
Wynik F1
Ta partytura da nam harmoniczną średnią precyzji i pamięci. Matematycznie, wynik F1 jest średnią ważoną precyzji i powtarzalności. Najlepsza wartość F1 to 1, a najgorsza 0. Możemy obliczyć wynik F1 za pomocą następującego wzoru -
= ∗ (∗) / (+)
Wynik F1 ma równy względny wpływ na precyzję i pamięć.
Możemy użyć funkcji Classification_report funkcji sklearn.metrics, aby uzyskać raport klasyfikacyjny naszego modelu klasyfikacyjnego.
AUC (obszar pod krzywą ROC)
AUC (obszar pod krzywą) -ROC (charakterystyka działania odbiornika) to miernik wydajności oparty na różnych wartościach progowych dla problemów klasyfikacyjnych. Jak sugeruje nazwa, ROC jest krzywą prawdopodobieństwa, a AUC jest miarą rozdzielności. W prostych słowach metryka AUC-ROC powie nam o zdolności modelu do rozróżniania klas. Im wyższa wartość AUC, tym lepszy model.
Matematycznie, można go utworzyć, wykreślając TPR (wskaźnik prawdziwie dodatnich), tj. Czułość lub przywołanie względem FPR (wskaźnik fałszywie dodatnich), tj. Swoistość 1, przy różnych wartościach progowych. Poniżej znajduje się wykres przedstawiający ROC, AUC z TPR na osi y i FPR na osi x -
Możemy użyć funkcji roc_auc_score sklearn.metrics do obliczenia AUC-ROC.
LOGLOSS (strata logarytmiczna)
Nazywa się to również utratą regresji logistycznej lub utratą krzyżowej entropii. Zasadniczo definiuje się go na szacunkach prawdopodobieństwa i mierzy wydajność modelu klasyfikacyjnego, w którym dane wejściowe mają wartość prawdopodobieństwa z zakresu od 0 do 1. Można to lepiej zrozumieć, różnicując je z dokładnością. Jak wiemy, dokładność to liczba prognoz (wartość przewidywana = wartość rzeczywista) w naszym modelu, podczas gdy strata logarytmiczna to wielkość niepewności naszej prognozy na podstawie tego, jak bardzo różni się ona od faktycznej etykiety. Z pomocą wartości Log Loss możemy mieć dokładniejszy obraz wydajności naszego modelu. Możemy użyć funkcji log_loss sklearn.metrics do obliczenia utraty logów.
Przykład
Poniżej znajduje się prosty przepis w Pythonie, który da nam wgląd w to, jak możemy wykorzystać wyżej wyjaśnione metryki wydajności w binarnym modelu klasyfikacji -
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import log_loss
X_actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
Y_predic = [1, 0, 1, 1, 1, 0, 1, 1, 0, 0]
results = confusion_matrix(X_actual, Y_predic)
print ('Confusion Matrix :')
print(results)
print ('Accuracy Score is',accuracy_score(X_actual, Y_predic))
print ('Classification Report : ')
print (classification_report(X_actual, Y_predic))
print('AUC-ROC:',roc_auc_score(X_actual, Y_predic))
print('LOGLOSS Value is',log_loss(X_actual, Y_predic))Wynik
Confusion Matrix :
[[3 3]
[1 3]]
Accuracy Score is 0.6
Classification Report :
precision recall f1-score support
0 0.75 0.50 0.60 6
1 0.50 0.75 0.60 4
micro avg 0.60 0.60 0.60 10
macro avg 0.62 0.62 0.60 10
weighted avg 0.65 0.60 0.60 10
AUC-ROC: 0.625
LOGLOSS Value is 13.815750437193334Wskaźniki wydajności dla problemów regresji
Omówiliśmy regresję i jej algorytmy w poprzednich rozdziałach. W tym miejscu omówimy różne metryki wydajności, których można użyć do oceny prognoz dotyczących problemów z regresją.
Średni błąd bezwzględny (MAE)
Jest to najprostsza miara błędu używana w problemach regresji. Jest to w zasadzie suma średniej bezwzględnej różnicy między wartościami przewidywanymi i rzeczywistymi. W prostych słowach dzięki MAE możemy zorientować się, jak błędne były przewidywania. MAE nie wskazuje kierunku modelu, tj. Nie wskazuje na gorsze lub nadmierne osiąganie modelu. Poniżej znajduje się wzór do obliczenia MAE -
$MAE = \frac{1}{n}\sum|Y -\hat{Y}|$Tutaj = Rzeczywiste wartości wyjściowe
I $\hat{Y}$= Przewidywane wartości wyjściowe.
Możemy użyć funkcji mean_absolute_error w sklearn.metrics do obliczenia MAE.
Błąd średniokwadratowy (MSE)
MSE jest podobne do MAE, ale jedyną różnicą jest to, że przed zsumowaniem ich wszystkich zsumuje różnicę rzeczywistych i przewidywanych wartości wyjściowych, zamiast używać wartości bezwzględnej. Różnicę można zauważyć w następującym równaniu -
$MSE = \frac{1}{n}\sum(Y -\hat{Y})$Tutaj = Rzeczywiste wartości wyjściowe
I $\hat{Y}$ = Przewidywane wartości wyjściowe.
Możemy użyć funkcji mean_squared_error w sklearn.metrics do obliczenia MSE.
R do kwadratu (R 2 )
Metryka R-kwadrat jest zwykle używana do celów wyjaśniających i zapewnia wskazanie dobroci lub dopasowania zestawu przewidywanych wartości wyjściowych do rzeczywistych wartości wyjściowych. Poniższa formuła pomoże nam to zrozumieć -
$R^{2} = 1 -\frac{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\hat{Y_{i}})^2}{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\bar{Y_i)^2}}$W powyższym równaniu licznik to MSE, a mianownik to wariancja wartości.
Możemy użyć funkcji r2_score sklearn.metrics do obliczenia wartości R do kwadratu.
Przykład
Poniżej znajduje się prosty przepis w Pythonie, który da nam wgląd w to, jak możemy wykorzystać wyżej wyjaśnione metryki wydajności w modelu regresji -
from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
X_actual = [5, -1, 2, 10]
Y_predic = [3.5, -0.9, 2, 9.9]
print ('R Squared =',r2_score(X_actual, Y_predic))
print ('MAE =',mean_absolute_error(X_actual, Y_predic))
print ('MSE =',mean_squared_error(X_actual, Y_predic))Wynik
R Squared = 0.9656060606060606
MAE = 0.42499999999999993
MSE = 0.5674999999999999Wprowadzenie
Aby pomyślnie wykonać i wygenerować wyniki, model uczenia maszynowego musi zautomatyzować niektóre standardowe przepływy pracy. Proces automatyzacji tych standardowych przepływów pracy można wykonać za pomocą potoków Scikit-learn. Z punktu widzenia analityka danych potok jest uogólnioną, ale bardzo ważną koncepcją. Zasadniczo umożliwia przepływ danych z surowego formatu do przydatnych informacji. Działanie rurociągów można zrozumieć za pomocą następującego schematu -
Bloki rurociągów ML są następujące -
Data ingestion- Jak sama nazwa wskazuje, jest to proces importowania danych do wykorzystania w projekcie ML. Dane można wyodrębniać w czasie rzeczywistym lub partiami z jednego lub wielu systemów. Jest to jeden z najtrudniejszych etapów, ponieważ jakość danych może wpływać na cały model ML.
Data Preparation- Po zaimportowaniu danych musimy przygotować dane do wykorzystania w naszym modelu ML. Wstępne przetwarzanie danych jest jedną z najważniejszych technik przygotowania danych.
ML Model Training- Następnym krokiem jest wyszkolenie naszego modelu ML. Mamy różne algorytmy ML, takie jak nadzorowane, nienadzorowane, wzmacniające, aby wyodrębniać cechy z danych i prognozować.
Model Evaluation- Następnie musimy ocenić model ML. W przypadku potoku AutoML model ML można ocenić za pomocą różnych metod statystycznych i reguł biznesowych.
ML Model retraining- W przypadku potoku AutoML nie jest konieczne, aby pierwszy model był najlepszy. Pierwszy model jest traktowany jako model bazowy i możemy go trenować wielokrotnie, aby zwiększyć dokładność modelu.
Deployment- Wreszcie musimy wdrożyć model. Ten krok obejmuje zastosowanie i migrację modelu do operacji biznesowych w celu ich wykorzystania.
Wyzwania towarzyszące rurociągom ML
Aby stworzyć potoki ML, naukowcy zajmujący się danymi stają przed wieloma wyzwaniami. Wyzwania te można podzielić na trzy kategorie -
Jakość danych
Sukces każdego modelu ML zależy w dużej mierze od jakości danych. Jeśli dane, które dostarczamy do modelu ML nie są dokładne, wiarygodne i solidne, skończymy na błędnych lub wprowadzających w błąd wynikach.
Niezawodność danych
Kolejnym wyzwaniem związanym z potokami ML jest wiarygodność danych, które dostarczamy do modelu ML. Jak wiemy, mogą istnieć różne źródła, z których analityk danych może pozyskiwać dane, ale aby uzyskać najlepsze wyniki, należy mieć pewność, że źródła danych są wiarygodne i zaufane.
Dostępność danych
Aby uzyskać najlepsze wyniki z potoków ML, same dane muszą być dostępne, co wymaga konsolidacji, czyszczenia i przechowywania danych. W wyniku właściwości dostępności danych metadane zostaną zaktualizowane o nowe tagi.
Modelowanie potoku ML i przygotowanie danych
Wyciek danych, występujący od zbioru danych treningowych do zestawu testowego, jest ważnym problemem, z którym musi się zmierzyć naukowiec zajmujący się danymi podczas przygotowywania danych do modelu ML. Ogólnie rzecz biorąc, w czasie przygotowywania danych analityk danych stosuje techniki takie jak standaryzacja lub normalizacja całego zbioru danych przed nauką. Ale te techniki nie mogą pomóc nam w wycieku danych, ponieważ na zbiór danych uczących wpłynęłaby skala danych w zbiorze danych testowych.
Korzystając z potoków ML, możemy zapobiec wyciekowi danych, ponieważ potoki zapewniają, że przygotowanie danych, takie jak standaryzacja, jest ograniczone do każdego fałdu naszej procedury weryfikacji krzyżowej.
Przykład
Poniżej znajduje się przykład w Pythonie, który demonstruje przygotowanie danych i przepływ pracy oceny modelu. W tym celu wykorzystujemy zbiór danych Pima Indian Diabetes firmy Sklearn. Najpierw stworzymy potok, który ustandaryzuje dane. Następnie zostanie utworzony model liniowej analizy dyskryminacyjnej i na koniec potok zostanie oceniony za pomocą 10-krotnej weryfikacji krzyżowej.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.discriminant_analysis import LinearDiscriminantAnalysisTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.valuesNastępnie utworzymy potok za pomocą następującego kodu -
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('lda', LinearDiscriminantAnalysis()))
model = Pipeline(estimators)W końcu zamierzamy ocenić ten potok i wyprowadzić jego dokładność w następujący sposób -
kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7790148448043184Powyższe dane wyjściowe to podsumowanie dokładności konfiguracji w zbiorze danych.
Modelowanie rurociągów ML i wydobywanie cech
Wyciek danych może również wystąpić na etapie wyodrębniania cech modelu ML. Dlatego procedury wyodrębniania cech powinny być również ograniczone, aby zatrzymać wyciek danych w naszym zestawie danych szkoleniowych. Podobnie jak w przypadku przygotowania danych, korzystając z potoków ML możemy również zapobiec wyciekowi danych. Do tego celu można użyć FeatureUnion, narzędzia udostępnianego przez potoki ML.
Przykład
Poniżej znajduje się przykład w języku Python, który demonstruje wyodrębnianie funkcji i przepływ pracy oceny modelu. W tym celu wykorzystujemy zbiór danych Pima Indian Diabetes firmy Sklearn.
Najpierw za pomocą PCA (analiza głównych komponentów) zostaną wyodrębnione 3 funkcje. Następnie 6 funkcji zostanie wyodrębnionych za pomocą analizy statystycznej. Po wyodrębnieniu funkcji wynik wyboru wielu funkcji i procedury ekstrakcji zostaną połączone za pomocą funkcji
Narzędzie FeatureUnion. W końcu zostanie utworzony model regresji logistycznej, a potok zostanie oceniony za pomocą 10-krotnej weryfikacji krzyżowej.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBestTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.valuesNastępnie połączenie funkcji zostanie utworzone w następujący sposób -
features = []
features.append(('pca', PCA(n_components=3)))
features.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(features)Następnie potok zostanie utworzony za pomocą następujących linii skryptu -
estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)W końcu zamierzamy ocenić ten potok i wyprowadzić jego dokładność w następujący sposób -
kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7789811066126855Powyższe dane wyjściowe to podsumowanie dokładności konfiguracji w zbiorze danych.
Poprawa wydajności z zespołami
Zespoły mogą zwiększyć wyniki uczenia maszynowego dzięki połączeniu kilku modeli. Zasadniczo modele zespołowe składają się z kilku indywidualnie szkolonych, nadzorowanych modeli uczenia się, a ich wyniki są łączone na różne sposoby, aby osiągnąć lepszą wydajność predykcyjną w porównaniu z pojedynczym modelem. Metody zespołowe można podzielić na dwie następujące grupy -
Sekwencyjne metody zespołowe
Jak sama nazwa wskazuje, w tego rodzaju metodach zespołowych podstawowe osoby uczące się są generowane sekwencyjnie. Motywacją do stosowania takich metod jest wykorzystanie zależności między podstawowymi uczniami.
Metody zespołowe równoległe
Jak sama nazwa wskazuje, w tego rodzaju metodach zespołowych podstawowe osoby uczące się są generowane równolegle. Motywacją takich metod jest wykorzystywanie niezależności wśród uczniów podstawowych.
Metody uczenia się zespołowego
Poniżej przedstawiono najpopularniejsze metody uczenia się zespołowego, czyli metody łączenia przewidywań z różnych modeli -
Parcianka
Termin „pakowanie” jest również nazywany agregacją bootstrap. W metodach zbiorczych model zespołowy próbuje poprawić dokładność przewidywania i zmniejszyć wariancję modelu poprzez łączenie przewidywań poszczególnych modeli trenowanych na losowo generowanych próbkach szkoleniowych. Ostateczna prognoza modelu zespołowego zostanie podana poprzez obliczenie średniej ze wszystkich przewidywań z poszczególnych estymatorów. Jednym z najlepszych przykładów metod workowania są losowe lasy.
Wzmocnienie
W metodzie wspomagającej główną zasadą budowania modelu zespołowego jest budowanie go przyrostowo poprzez sekwencyjne szkolenie każdego estymatora modelu podstawowego. Jak sama nazwa wskazuje, w zasadzie składa się z kilku tygodniowych podstawowych uczniów, przeszkolonych sekwencyjnie na wielu iteracjach danych szkoleniowych, aby zbudować potężny zespół. Podczas szkolenia uczniów bazujących na tygodniowej podstawie, wyższe wagi są przypisywane tym uczniom, którzy wcześniej zostali błędnie sklasyfikowani. Przykładem metody boostingu jest AdaBoost.
Głosowanie
W tym zespolonym modelu uczenia się budowanych jest wiele modeli różnych typów, a niektóre proste statystyki, takie jak obliczanie średniej lub mediany itp., Są wykorzystywane do łączenia prognoz. Ta prognoza posłuży jako dodatkowe dane wejściowe do treningu, aby dokonać ostatecznej prognozy.
Algorytmy zespołu pakowania
Poniżej przedstawiono trzy algorytmy zestawu workowania -
Drzewo decyzyjne w workach
Ponieważ wiemy, że metody grupowania zbiorów dobrze współpracują z algorytmami o dużej wariancji i pod tym względem najlepszym z nich jest algorytm drzewa decyzyjnego. W poniższym przepisie Pythona zamierzamy zbudować model zespołu drzew decyzyjnych w workach, używając funkcji sklearn BaggingClassifier z DecisionTreeClasifier (algorytmem drzew klasyfikacyjnych i regresyjnych) na zbiorze danych dotyczących cukrzycy Indian Pima.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak to zrobiliśmy w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()Musimy podać liczbę drzew, które zamierzamy zbudować. Tutaj budujemy 150 drzew -
num_trees = 150Następnie zbuduj model za pomocą następującego skryptu -
model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)Oblicz i wydrukuj wynik w następujący sposób -
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7733766233766234Powyższe dane wyjściowe pokazują, że otrzymaliśmy około 77% dokładności naszego modelu klasyfikatora z workowanym drzewem decyzyjnym.
Losowy las
Jest to rozszerzenie zapakowanych drzew decyzyjnych. W przypadku klasyfikatorów indywidualnych pobierane są próbki zbioru uczącego z wymianą, ale drzewa są konstruowane w taki sposób, aby zmniejszyć korelację między nimi. Rozważa się również losowy podzbiór cech, aby wybrać każdy punkt podziału, zamiast chciwie wybierać najlepszy punkt podziału w konstrukcji każdego drzewa.
W poniższym przepisie Pythona zamierzamy zbudować losowy model zespołu lasu z wykorzystaniem klasy sklearn RandomForestClassifier w zbiorze danych o cukrzycy Pima Indians.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
seed = 7
kfold = KFold(n_splits=10, random_state=seed)Musimy podać liczbę drzew, które zamierzamy zbudować. Tutaj budujemy 150 drzew z punktami podziału wybranymi z 5 cech -
num_trees = 150
max_features = 5Następnie zbuduj model za pomocą następującego skryptu -
model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)Oblicz i wydrukuj wynik w następujący sposób -
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7629357484620642Powyższe dane wyjściowe pokazują, że otrzymaliśmy około 76% dokładności naszego workowego modelu losowego klasyfikatora lasu.
Dodatkowe drzewa
Jest to kolejne rozszerzenie metody zespolonego drzewa decyzyjnego w workach. W tej metodzie losowe drzewa są konstruowane z próbek zbioru uczącego.
W poniższym przepisie Pythona zamierzamy zbudować dodatkowy model zespołu drzewa przy użyciu klasy sklearn ExtraTreesClassifier w zbiorze danych dotyczących cukrzycy Pima Indians.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
seed = 7
kfold = KFold(n_splits=10, random_state=seed)Musimy podać liczbę drzew, które zamierzamy zbudować. Tutaj budujemy 150 drzew z punktami podziału wybranymi z 5 cech -
num_trees = 150
max_features = 5Następnie zbuduj model za pomocą następującego skryptu -
model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)Oblicz i wydrukuj wynik w następujący sposób -
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7551435406698566Powyższe dane wyjściowe pokazują, że otrzymaliśmy około 75,5% dokładności naszego modelu klasyfikatora dodatkowych drzew w workach.
Zwiększanie algorytmów zespołu
Poniżej przedstawiono dwa najpopularniejsze algorytmy wzmacniające zespoły -
AdaBoost
Jest to jeden z najbardziej skutecznych algorytmów wzmacniających. Głównym kluczem tego algorytmu jest sposób, w jaki nadają wagi instancjom w zbiorze danych. Z tego powodu algorytm musi zwracać mniejszą uwagę na instancje podczas konstruowania kolejnych modeli.
W poniższym przepisie Pythona zamierzamy zbudować model zespołu Ada Boost do klasyfikacji przy użyciu klasy sklearn klasy AdaBoostClassifier w zbiorze danych o cukrzycy Indianie Pima.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
seed = 5
kfold = KFold(n_splits=10, random_state=seed)Musimy podać liczbę drzew, które zamierzamy zbudować. Tutaj budujemy 150 drzew z punktami podziału wybranymi z 5 cech -
num_trees = 50Następnie zbuduj model za pomocą następującego skryptu -
model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)Oblicz i wydrukuj wynik w następujący sposób -
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7539473684210527Powyższe dane wyjściowe pokazują, że otrzymaliśmy około 75% dokładności naszego modelu zespołu klasyfikatorów AdaBoost.
Stochastic Gradient Boosting
Nazywa się to również Gradient Boosting Machines. W poniższym przepisie Pythona zamierzamy zbudować model Stochastic Gradient Boostingensemble do klasyfikacji przy użyciu klasy Sklearn GradientBoostingClassifier ze zbioru danych dotyczących cukrzycy Pima Indians.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
seed = 5
kfold = KFold(n_splits=10, random_state=seed)Musimy podać liczbę drzew, które zamierzamy zbudować. Tutaj budujemy 150 drzew z punktami podziału wybranymi z 5 cech -
num_trees = 50Następnie zbuduj model za pomocą następującego skryptu -
model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)Oblicz i wydrukuj wynik w następujący sposób -
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())Wynik
0.7746582365003418Powyższe dane wyjściowe pokazują, że uzyskaliśmy około 77,5% dokładności naszego modelu zespołowego klasyfikatora Gradient Boosting.
Algorytmy zespołu głosowania
Jak już wspomniano, głosowanie najpierw tworzy dwa lub więcej samodzielnych modeli ze szkoleniowego zestawu danych, a następnie klasyfikator z głosowaniem zawinie model wraz z obliczeniem średniej prognoz dla podmodelu, gdy będą potrzebne nowe dane.
W poniższym przepisie Pythona zamierzamy zbudować model zespołu Voting do klasyfikacji przy użyciu klasy sklearn klasy VotingClassifier ze zbioru danych dotyczących cukrzycy Pima Indians. Łączymy razem prognozy regresji logistycznej, klasyfikatora drzewa decyzyjnego i SVM w celu rozwiązania problemu klasyfikacyjnego w następujący sposób -
Najpierw zaimportuj wymagane pakiety w następujący sposób -
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifierTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie podaj dane wejściowe do 10-krotnej weryfikacji krzyżowej w następujący sposób -
kfold = KFold(n_splits=10, random_state=7)Następnie musimy stworzyć pod-modele w następujący sposób -
estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))Teraz utwórz model zespołu z głosowaniem, łącząc przewidywania z utworzonych powyżej modeli podrzędnych.
ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())Wynik
0.7382262474367738Powyższe dane wyjściowe pokazują, że otrzymaliśmy około 74% dokładności naszego modelu zespołu klasyfikatorów głosowania.
Poprawa wydajności dzięki dostrajaniu algorytmu
Jak wiemy, modele ML są sparametryzowane w taki sposób, że ich zachowanie można dostosować do konkretnego problemu. Strojenie algorytmu oznacza znalezienie najlepszej kombinacji tych parametrów, tak aby można było poprawić wydajność modelu ML. Proces ten czasami nazywany jest optymalizacją hiperparametrów, a parametry samego algorytmu nazywane są hiperparametrami, a współczynniki znalezione przez algorytm ML nazywane są parametrami.
W tym miejscu omówimy niektóre metody dostrajania parametrów algorytmu udostępniane przez Python Scikit-learn.
Dostrajanie parametrów wyszukiwania siatki
Jest to podejście do strojenia parametrów. Kluczowym punktem pracy tej metody jest to, że buduje i ocenia model metodycznie dla każdej możliwej kombinacji parametrów algorytmu określonych w siatce. Stąd możemy powiedzieć, że ten algorytm ma charakter przeszukiwania.
Przykład
W poniższym przepisie Pythona zamierzamy przeprowadzić wyszukiwanie w siatce przy użyciu klasy sklearn GridSearchCV do oceny różnych wartości alfa dla algorytmu Ridge Regression na zbiorze danych dotyczących cukrzycy Indian Pima.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
import numpy
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCVTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie oceń różne wartości alfa w następujący sposób -
alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)Teraz musimy zastosować wyszukiwanie siatki w naszym modelu -
model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)Wydrukuj wynik za pomocą następującej linii skryptu -
print(grid.best_score_)
print(grid.best_estimator_.alpha)Wynik
0.2796175593129722
1.0Powyższe dane wyjściowe dają nam optymalny wynik i zestaw parametrów w siatce, które osiągnęły ten wynik. Wartość alfa w tym przypadku wynosi 1,0.
Losowe dostrajanie parametrów wyszukiwania
Jest to podejście do strojenia parametrów. Kluczowym punktem działania tej metody jest próbkowanie parametrów algorytmu z losowego rozkładu dla ustalonej liczby iteracji.
Przykład
W poniższym przepisie Pythona zamierzamy przeprowadzić losowe wyszukiwanie przy użyciu klasy sklearn RandomizedSearchCV do oceny różnych wartości alfa od 0 do 1 dla algorytmu Ridge Regression na zbiorze danych dotyczących cukrzycy Indian Pima.
Najpierw zaimportuj wymagane pakiety w następujący sposób -
import numpy
from pandas import read_csv
from scipy.stats import uniform
from sklearn.linear_model import Ridge
from sklearn.model_selection import RandomizedSearchCVTeraz musimy załadować zestaw danych dotyczących cukrzycy Pima, tak jak w poprzednich przykładach -
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]Następnie oceń różne wartości alfa algorytmu regresji Ridge w następujący sposób -
param_grid = {'alpha': uniform()}
model = Ridge()
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=50,
random_state=7)
random_search.fit(X, Y)Wydrukuj wynik za pomocą następującej linii skryptu -
print(random_search.best_score_)
print(random_search.best_estimator_.alpha)Wynik
0.27961712703051084
0.9779895119966027
0.9779895119966027Powyższe dane wyjściowe dają nam optymalny wynik, podobny do wyszukiwania w siatce.