Uczenie maszynowe w Javie – pierwsze kroki z Weka

Uczenie maszynowe stało się technologią transformacyjną umożliwiającą komputerom uczenie się na podstawie danych i podejmowanie inteligentnych decyzji. Wśród mnóstwa narzędzi je wykorzystujących wyróżnia się Weka – potężny i łatwy w użytku framework oferujący bezproblemowy dostęp do świata spostrzeżeń opartych na danych. W tym artykule przedstawiam podstawy uczenia maszynowego przy użyciu Weka w języku Java. Zagłębiam się też w podstawowe pojęcia, a także tematy wstępnego przetwarzania danych, szkolenia modeli i ewaluacji. Całość poparta jest ilustracyjnymi przykładami kodu w Javie.

Wstępne wymagania

Zanim zagłębisz się w narzędziu Weka, upewnij się, że masz:

• zainstalowany Java Development Kit (JDK);
• pobraną i dodaną do projektu Java bibliotekę Weka.

Zapoznanie się z Weka

Weka to zestaw narzędzi do uczenia maszynowego open-source, który upraszcza złożoność uczenia maszynowego. Zapewnia szeroką gamę algorytmów klasyfikacji, regresji, grupowania i innych. Jak zacząć ją używać? Zacznij od załadowania zbioru danych i zastosowania podstawowego modelu klasyfikacji. Spójrz:

import weka.classifiers.bayes.NaiveBayes;
import weka.core.Instances;

import static weka.core.converters.ConverterUtils.DataSource;

public class WekaDemo {

  public static void main(String[] args) throws Exception {
    // Załadowanie danych
    DataSource source = new DataSource("iris.arff");
    Instances dataset = source.getDataSet();
    dataset.setClassIndex(dataset.numAttributes() - 1);

    // Budowanie i ocena modelu
    NaiveBayes classifier = new NaiveBayes();
    classifier.buildClassifier(dataset);

    // Wypisanie rezultatu
    System.out.println(classifier);
  }
}

Rezultat:

Naive Bayes Classifier

                         Class
Attribute          Iris-setosa Iris-versicolor  Iris-virginica
                        (0.33)          (0.33)          (0.33)
===============================================================
sepallength
  mean                   4.9913          5.9379          6.5795
  std. dev.               0.355          0.5042          0.6353
  weight sum                 50              50              50
  precision              0.1059          0.1059          0.1059

sepalwidth
  mean                   3.4015          2.7687          2.9629
  std. dev.              0.3925          0.3038          0.3088
  weight sum                 50              50              50
  precision              0.1091          0.1091          0.1091

petallength
  mean                   1.4694          4.2452          5.5516
  std. dev.              0.1782          0.4712          0.5529
  weight sum                 50              50              50
  precision              0.1405          0.1405          0.1405

petalwidth
  mean                   0.2743          1.3097          2.0343
  std. dev.              0.1096          0.1915          0.2646
  weight sum                 50              50              50
  precision              0.1143          0.1143          0.1143

W tym przykładzie ładujemy klasyczny zbiór danych Iris („iris.arff”) za pomocą DataSource Weka. Ustawiamy indeks klasy i budujemy prosty klasyfikator Naive Bayes przy użyciu klasy NaiveBayes. Na koniec wypisujemy podsumowanie modelu.

Co to jest algorytm Naive Bayes?

Naive Bayes to algorytm uczenia maszynowego wykorzystywany głównie do zadań klasyfikacyjnych. Jest on szczególnie przydatny, gdy chcemy zaklasyfikować dane do predefiniowanych kategorii lub klas na podstawie cech wejściowych. Algorytm ten opiera się na twierdzeniu Bayesa i zakłada niezależność między właściwościami, dlatego też nazywany jest „naiwnym”.

• Pomimo swojego „naiwnego” założenia” Naive Bayes często dobrze radzi sobie z szerokim zakresem zadań klasyfikacyjnych, zwłaszcza w przypadku danych wielowymiarowych, takich jak tekst. Jest stosunkowo prosty, wydajny obliczeniowo i może zapewnić dokładne wyniki przy stosunkowo niewielkiej ilości danych treningowych. Może jednak nie działać dobrze w przypadkach, gdy zależności cech są kluczowe dla dokładnej klasyfikacji lub gdy zbiór danych jest znacznie niezrównoważony.

Wstępne przetwarzanie danych

Wstępne przetwarzanie danych ma kluczowe znaczenie dla skutecznego uczenia maszynowego. Weka zapewnia narzędzia do obsłużenia brakujących wartości, normalizacji danych i nie tylko.

Normalizacja i dyskretyzacja danych to dwie techniki wstępnego przetwarzania powszechnie stosowane w uczeniu maszynowym w celu poprawy wydajności algorytmów i interpretowalności danych. Techniki te są dostępne jako filtry w zestawie narzędzi uczenia maszynowego Weka.

Normalizacja danych

Znana również jako skalowanie właściwości jest procesem przekształcania właściwości tak, aby miały spójną skalę. Ma to kluczowe znaczenie, gdy funkcje mają różne zakresy, a niektóre algorytmy uczenia maszynowego, takie jak te oparte na gradientach, są wrażliwe na skale funkcji.

Dyskretyzacja danych

Obejmuje konwersję danych ciągłych na wartości dyskretne. Często wykorzystuje się ją w celu uproszczenia danych, uczynienia ich bardziej zrozumiałymi i zmniejszenia szumów. Dyskretyzacja jest szczególnie przydatna dla algorytmów, które pracują z danymi kategoryzacyjnymi lub które działają lepiej, gdy dane są pogrupowane.

import weka.core.Instances;
import weka.filters.Filter;
import weka.filters.supervised.attribute.Discretize;
import weka.filters.unsupervised.attribute.Normalize;

import static weka.core.converters.ConverterUtils.DataSource;

public class DataPreprocessing {

  public static void main(String[] args) throws Exception {
    // Załadowanie danych
    DataSource source = new DataSource("src/main/java/weka/diabetes.arff");
    Instances dataset = source.getDataSet();
    dataset.setClassIndex(dataset.numAttributes() - 1);

    // Normalizacja danych
    Normalize normalize = new Normalize();
    normalize.setInputFormat(dataset);
    Instances normalizedDataset = Filter.useFilter(dataset, normalize);

    // Dyskretyzacja danych
    Discretize discretize = new Discretize();
    discretize.setInputFormat(normalizedDataset);
    Instances discretizedDataset = Filter.useFilter(normalizedDataset, discretize);

    System.out.println(discretizedDataset);
  }
}

W tym przykładzie ładujemy zbiór danych „diabetes.arff” i wykonujemy normalizację oraz dyskretyzację danych przy użyciu filtrów Weka.

• Pamiętaj, że wybór metod normalizacji i dyskretyzacji powinien zależeć od charakterystyki danych i wymagań algorytmu uczenia maszynowego. Korzystanie z tych technik wstępnego przetwarzania może znacznie poprawić wydajność i niezawodność modeli uczenia maszynowego poprzez zmniejszenie wpływu skal cech i zwiększenie możliwości interpretacji danych.

Ocena modelu

Ewaluacja modelu jest krytycznym krokiem w procesie uczenia maszynowego. Obejmuje ona ocenę wydajności wytrenowanego modelu na niewidzianych wcześniej danych. Weka zapewnia różne narzędzia i techniki oceny modeli. Głównym celem ewaluacji modelu jest zrozumienie, jak dobrze może on generalizować na nowe dane, a także zidentyfikowanie wszelkich potencjalnych problemów lub obszarów wymagających poprawy. Jak wygląda proces oceny modelu przy użyciu Weka? Spójrz:

import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.evaluation.Evaluation;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;

public class ModelEvaluation {

  public static void main(String[] args) throws Exception {
    // Załadowanie danych
    DataSource source = new DataSource("src/main/java/weka/heart.arff");
    Instances dataset = source.getDataSet();
    dataset.setClassIndex(dataset.numAttributes() - 1);

    // Budowanie modelu
    NaiveBayes classifier = new NaiveBayes();
    classifier.buildClassifier(dataset);

    // Ocena modelu
    Evaluation evaluation = new Evaluation(dataset);
    evaluation.evaluateModel(classifier, dataset);

    System.out.println(evaluation.toSummaryString());
  }
}

Rezultat:

Correctly Classified Instances         255               84.1584 %
Incorrectly Classified Instances        48               15.8416 %
Kappa statistic                          0.6795
Mean absolute error                      0.068 
Root mean squared error                  0.2182
Relative absolute error                 33.9218 %
Root relative squared error             69.2704 %
Total Number of Instances              303 

W tym przykładzie ładujemy zbiór danych „heart.arff”, budujemy model Naive Bayes i oceniamy jego wydajność za pomocą klasy Evaluation w Weka.

• Podsumowując, ewaluacja modelu jest kluczowym krokiem w procesie uczenia maszynowego. Umożliwia ona ocenę wydajności modelu na niewidzianych wcześniej danych. Weka zapewnia różnorodne narzędzia i metody oceny klasyfikatorów, regresorów i innych modeli. Oprócz tego dostarcza wizualizacje pomagające w interpretacji wyników i porównywaniu modeli.

Podsumowanie

Weka stanowi doskonały punkt wyjścia dla tych, którzy chcą poznać świat uczenia maszynowego z wykorzystaniem języka Java. Przyjazny interfejs, różnorodne algorytmy i wszechstronny zestaw narzędzi umożliwiają programistom eksplorowanie, eksperymentowanie i uzyskiwanie wglądu w dane. Czy warto kontynuować swoją przygodę z uczeniem maszynowym? Zdecydowanie tak, ponieważ dzięki temu możesz zagłębić się w bardziej zaawansowane techniki, eksplorować różnorodne zbiory danych i udoskonalać swoje modele. Z Weka w swoim arsenale możesz wykorzystać moc uczenia maszynowego w ekosystemie Java.

Żródła

• https://waikato.github.io/weka-wiki/
• https://github.com/Hyarcher/Weka/tree/master