Обзор библиотек для машинного обучения на Python — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Исправил ссылку на примеры Java)
Строка 1: Строка 1:
[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]
+
[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
 
+
==Популярные библиотеки==
==Scikit-learn==
+
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
===Описание===
+
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]]<sup>[на 28.01.19 не создан]</sup>. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]]<sup>[на 28.01.19 не создан]</sup> и её модификаций Лассо, гребневой регрессии, [[Метод опорных векторов (SVM)|опорных векторов]]<sup>[на 28.01.19 не создан]</sup>, [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]]<sup>[на 28.01.19 не создан]</sup>. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.
+
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
 
+
==Примеры кода==
===Примеры кода===
+
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>.<br>
 +
Каждый пример структурирован следующим образом:
 +
# <code>Maven</code> зависимость на необходимые библиотеки
 +
# Список необходимых <code>import</code> директив
 +
# Код примера с комментариями
 +
===Вариации регрессии===
 +
{{main|Вариации регрессии}}
 
====Линейная регрессия====
 
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия<sup>[на 28.01.19 не создан]</sup>}}
+
{{main|Линейная регрессия}}
 
+
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>
  <font color="green"># Add required imports</font>
 
  '''import''' matplotlib.pyplot '''as''' plt
 
  '''import''' numpy '''as''' np
 
  '''from''' sklearn '''import''' datasets
 
  '''from''' sklearn.linear_model '''import''' LinearRegression
 
  '''from''' sklearn.metrics '''import''' mean_squared_error, r2_score
 
 
 
Загрузка датасета:
 
  diabetes = datasets.load_diabetes()
 
  <font color="green"># Use only one feature</font>
 
  diabetes_X = diabetes.data[:, np.newaxis, <font color="blue">2</font>]
 
 
 
Разбиение датасета на тренировочный и тестовый:
 
  <font color="green"># Split the data into training/testing sets</font>
 
  x_train = diabetes_X[:<font color="blue">-20</font>]
 
  x_test = diabetes_X[<font color="blue">-20</font>:]
 
 
 
  <font color="green"># Split the targets into training/testing sets</font>
 
  y_train = diabetes.target[:<font color="blue">-20</font>]
 
  y_test = diabetes.target[<font color="blue">-20</font>:]
 
 
 
Построение и обучение модели:
 
  lr = LinearRegression()
 
  lr.fit(x_train, y_train)
 
  predictions = lr.predict(x_test)
 
 
 
Оценка алгоритма:
 
  <font color="green"># The mean squared error</font>
 
  print(<font color="red">"Mean squared error: %.2f"</font>
 
        % mean_squared_error(y_test, predictions))
 
  <font color="green"># Explained variance score: 1 is perfect prediction</font>
 
  print(<font color="red">'Variance score: %.2f'</font> % r2_score(y_test, predictions))
 
 
 
  > '''Mean squared error: 2548.07'''
 
    '''Variance score: 0.47'''
 
 
 
Построение графика прямой, получившейся в результате работы линейной регрессии:
 
  plt.scatter(x_test, y_test,  color=<font color="red">'black'</font>)
 
  plt.plot(x_test, predictions, color=<font color="red">'blue'</font>, linewidth=<font color="blue">3</font>)
 
  plt.xticks(())
 
  plt.yticks(())
 
  plt.show()
 
 
 
[[File:Diabetes-sklearn.png|400px|none|super]]
 
  
====Логистическая регрессия====
+
  <dependency>
{{Main|Логистическая регрессия}}
+
    <groupId>nz.ac.waikato.cms.weka</groupId>
 +
    <artifactId>weka-stable</artifactId>
 +
    <version>3.8.0</version>
 +
  </dependency>
  
Загрузка датасета:
+
   '''import''' weka.classifiers.functions.LinearRegression;
   '''from''' sklearn.datasets '''import''' load_digits
+
  '''import''' weka.core.Instance;
   digits = load_digits()
+
   '''import''' weka.core.Instances;
  
Вывод первых трех тренировочных данных для визуализации:
+
   <font color="green">//Load Data set</font>
   '''import''' numpy '''as''' np
+
   '''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
   '''import''' matplotlib.pyplot '''as''' plt
+
   data.setClassIndex(data.numAttributes() - 1);
    
+
  <font color="green">//Build model</font>
  plt.figure(figsize=(<font color="blue">20</font>,<font color="blue">4</font>))
+
  '''var''' model = new LinearRegression();
   '''for''' index, (image, label) '''in''' enumerate(zip(digits.data[<font color="blue">0</font>:<font color="blue">3</font>], digits.target[<font color="blue">0</font>:<font color="blue">3</font>])):
+
   '''try''' { model.buildClassifier(data); }
    plt.subplot(<font color="blue">1</font>, <font color="blue">3</font>, index + <font color="blue">1</font>)
+
  '''catch''' (Exception e) { e.printStackTrace(); }
    plt.imshow(np.reshape(image, (<font color="blue">8</font>,<font color="blue">8</font>)), cmap=plt.cm.gray)
+
  <font color="green">//output model</font>
    plt.title(<font color="red">'Training: %i\n'</font> % label, fontsize = <font color="blue">20</font>)
+
  System.out.printf("model parameters: %s%n", model);
 +
  <font color="green">// Now Predicting the cost</font>
 +
  '''var''' myHouse = data.lastInstance();
 +
  '''var''' price  = model.classifyInstance(myHouse);
 +
  System.out.printf("predicted price = %s%n", price)
 +
====Логистическая регрессиия====
 +
{{main|Логистическая регрессия}}
 +
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>
  
[[File:Digits-sklearn.png|800px|none|super]]
+
  <dependency>
 +
    <groupId>com.github.haifengl</groupId>
 +
    <artifactId>smile-core</artifactId>
 +
    <version>1.5.2</version>
 +
  </dependency>
  
Разбиение датасета на тренировочный и тестовый:
+
  '''import''' smile.data.AttributeDataset;
   '''from''' sklearn.model_selection '''import''' train_test_split
+
   '''import''' smile.data.NominalAttribute;
   x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=<font color="blue">0.25</font>, random_state=<font color="blue">0</font>)
+
  '''import''' smile.classification.LogisticRegression;
 +
   '''import''' smile.data.parser.ArffParser;
  
Построение и обучение модели:
+
   '''var''' arffParser = new ArffParser();
   '''from''' sklearn.linear_model '''import''' LogisticRegression
+
  arffParser.setResponseIndex(4);
   lr = LogisticRegression()
+
  '''var''' iris   = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
   lr.fit(x_train, y_train)
+
   '''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
   predictions = lr.predict(x_test)
+
   logClf.predict(testX);
 +
====Гребневая регрессия (ридж-регрессия)====
 +
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}
  
Оценка алгоритма:
+
Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>
  score = lr.score(x_test, y_test)
 
  print(<font color="red">"Score: %.3f"</font> % score)
 
  
   > '''Score: 0.953'''
+
   <dependency>
 +
    <groupId>com.github.haifengl</groupId>
 +
    <artifactId>smile-core</artifactId>
 +
    <version>1.5.2</version>
 +
  </dependency>
  
====Перцептрон====
+
  '''import''' smile.data.NominalAttribute;
{{Main|Нейронные сети, перцептрон}}
+
  '''import''' smile.data.parser.DelimitedTextParser;
 +
  '''import''' smile.regression.RidgeRegression;
  
Загрузка датасета:
+
  '''var''' parser = new DelimitedTextParser();
   '''from''' sklearn '''import''' datasets
+
  parser.setDelimiter(", ");
   iris = datasets.load_iris()
+
  parser.setResponseIndex(new NominalAttribute("class"), 0);
   X = iris.data
+
   '''var''' dataset  = parser.parse("dataset.csv");
  y = iris.target
+
  '''var''' lambda  = 0.0057d;
 +
   '''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
 +
   ridgeClf.predict(testX);
 +
====Лассо-регрессия====
 +
{{Main|Вариации регрессии#Лассо-регрессия}}
  
Разбиение датасета на тренировочный и тестовый:
+
Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>
  '''from''' sklearn.model_selection '''import''' train_test_split
 
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = <font color="blue">0.20</font>)
 
  
Трансформация признаков:
+
  <dependency>
  '''from''' sklearn.preprocessing '''import''' StandardScaler
+
    <groupId>com.github.haifengl</groupId>
  scaler = StandardScaler()
+
    <artifactId>smile-core</artifactId>
  scaler.fit(X_train)
+
    <version>1.5.2</version>
  X_train = scaler.transform(X_train)
+
   </dependency>
   X_test = scaler.transform(X_test)
 
  
Построение и обучение модели:
+
   '''import''' smile.data.NominalAttribute;
   '''from''' sklearn.neural_network '''import''' MLPClassifier
+
  '''import''' smile.data.parser.DelimitedTextParser;
  mlp = MLPClassifier(hidden_layer_sizes=(<font color="blue">10</font>, <font color="blue">10</font>, <font color="blue">10</font>), max_iter=<font color="blue">1000</font>)
+
   '''import''' smile.regression.LASSO;
  mlp.fit(X_train, y_train.values.ravel())
 
   predictions = mlp.predict(X_test)
 
  
Оценка алгоритма:
+
  '''var''' parser = new DelimitedTextParser();
   '''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
+
  parser.setDelimiter(", ");
   print(confusion_matrix(y_test,predictions))
+
  parser.setResponseIndex(new NominalAttribute("class"), 0);
   print(classification_report(y_test,predictions))
+
   '''var''' dataset = parser.parse("dataset.csv");
 +
  '''var''' lasso   = new LASSO(dataset.x(), dataset.y(), 10);
 +
   lasso.predict(testX);
 +
===Классификация при помощи MLP===
 +
{{main|Нейронные сети, перцептрон}}
 +
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>
  
   > '''[[ 7  0  0]'''
+
   <dependency>
    '''[ 0  8  1]'''
+
    <groupId>nz.ac.waikato.cms.weka</groupId>
    '''[ 0  2 12]]'''
+
    <artifactId>weka-stable</artifactId>
                  '''precision    recall  f1-score  support'''
+
    <version>3.8.0</version>
 
+
   </dependency>
              '''0      1.00      1.00      1.00        7'''
 
              '''1      0.80      0.89      0.84        9'''
 
              '''2      0.92      0.86      0.89        14'''
 
    
 
      '''micro avg      0.90      0.90      0.90        30'''
 
      '''macro avg      0.91      0.92      0.91        30'''
 
    '''weighted avg      0.90      0.90      0.90        30'''
 
  
====Метрический классификатор и метод ближайших соседей====
+
  '''import''' weka.classifiers.functions.MultilayerPerceptron;
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}
+
  '''import''' weka.core.converters.CSVLoader;
 +
  '''import''' java.io.File;
  
====Дерево решений и случайный лес====
+
  <font color="green">// read train & test datasets and build MLP classifier</font>
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}
+
  '''var''' trainds = new DataSource("etc/train.csv");
 +
  '''var''' train  = trainds.getDataSet();
 +
  train.setClassIndex(train.numAttributes() - 1);
 +
  '''var''' testds = new DataSource("etc/test.csv");
 +
  '''var''' test  = testds.getDataSet();
 +
  test.setClassIndex(test.numAttributes() - 1);
 +
  '''var''' mlp = new MultilayerPerceptron();
 +
  mlp.buildClassifier(train);
 +
  <font color="green">// Test the model</font>
 +
  '''var''' eTest = new Evaluation(train);
 +
  eTest.evaluateModel(mlp, test);
 +
  <font color="green">// Print the result à la Weka explorer:</font>
 +
  '''var''' strSummary = eTest.toSummaryString();
 +
  System.out.println(strSummary);
  
====Обработка естественного языка====
+
===Рекуррентные нейронные сети===
{{Main|Обработка естественного языка}}
+
{{Main|Рекуррентные нейронные сети}}
 +
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
 +
===Долгая краткосрочная память===
 +
{{Main|Долгая краткосрочная память}}
 +
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
 +
===Метод опорных векторов===
 +
{{main|Метод опорных векторов (SVM)}}
 +
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>
  
Загрузка датасета:
+
  <dependency>
  '''from''' sklearn '''import''' fetch_20newsgroups
+
    <groupId>com.github.haifengl</groupId>
  twenty_train = fetch_20newsgroups(subset=<font color="red">'train'</font>, shuffle='''True''', random_state=<font color="blue">42</font>)
+
    <artifactId>smile-core</artifactId>
 +
    <version>1.5.2</version>
 +
  </dependency>
  
Вывод первых трех строк первого тренивочного файла и его класса:
+
  '''import''' smile.classification.SVM;
   print(<font color="red">"\n"</font>.join(twenty_train.data[<font color="blue">0</font>].split(<font color="red">"\n"</font>)[:<font color="blue">3</font>]))
+
   '''import''' smile.data.NominalAttribute;
   print(twenty_train.target_names[twenty_train.target[<font color="blue">0</font>]])
+
  '''import''' smile.data.parser.DelimitedTextParser;
 +
  '''import''' smile.math.kernel.GaussianKernel;
 +
   '''import''' java.util.Arrays;
  
   > '''From: lerxst@wam.umd.edu (where's my thing)'''
+
   <font color="green">// read train & test dataset</font>
    '''Subject: WHAT car is this!?'''
+
   '''var''' parser = new DelimitedTextParser();
    '''Nntp-Posting-Host: rac3.wam.umd.edu'''
+
   parser.setResponseIndex(new NominalAttribute("class"), 0);
 
+
   '''var''' train   = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
    '''rec.autos'''
+
   '''var''' test    = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
 
+
  '''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]]<sup>[на 28.01.19 не создан]</sup>, а вторая использует метод опорных векторов:
+
   <font color="green">// build SVM classifier</font>
   '''from''' sklearn.pipeline '''import''' Pipeline
+
  '''var''' svm    = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
   '''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer
+
   svm.learn(train.x(), train.labels());
 
+
   svm.finish();
   '''from''' sklearn.naive_bayes '''import''' MultinomialNB
+
   <font color="green">// calculate test error rate</font>
   text_clf1 = Pipeline([
+
   '''var''' error = 0;
    (<font color="red">'vect'</font>, CountVectorizer()),
+
  for (int i = 0; i < test.x().length; i++) {
    (<font color="red">'tfidf'</font>, TfidfTransformer()),
+
  if (svm.predict(test.x()[i]) != test.labels()[i]) {
    (<font color="red">'clf'</font>, MultinomialNB()),
+
    error++;
  ])
+
    }
 
 
   '''from''' sklearn.linear_model '''import''' SGDClassifier
 
  text_clf2 = Pipeline([
 
    (<font color="red">'vect'</font>, CountVectorizer()),
 
    (<font color="red">'tfidf'</font>, TfidfTransformer()),
 
    (<font color="red">'clf'</font>, SGDClassifier(loss=<font color="red">'hinge'</font>, penalty=<font color="red">'l2'</font>,
 
                          alpha=<font color="blue">1e-3</font>, random_state=<font color="blue">42</font>,
 
                          max_iter=<font color="blue">5</font>, tol='''None''')),
 
  ])
 
 
 
  text_clf1.fit(twenty_train.data, twenty_train.target)
 
  text_clf2.fit(twenty_train.data, twenty_train.target)
 
 
 
Оценка алгоритмов:
 
   twenty_test = fetch_20newsgroups(subset=<font color="red">'test'</font>, shuffle='''True''', random_state=<font color="blue">42</font>)
 
   docs_test = twenty_test.data
 
  predicted1 = text_clf1.predict(docs_test)
 
  predicted2 = text_clf2.predict(docs_test)
 
   print(<font color="red">"Score: %.3f"</font> % np.mean(predicted1 == twenty_test.target))
 
   print(<font color="red">"Score: %.3f"</font> % np.mean(predicted2 == twenty_test.target))
 
 
 
   > '''Score for naive Bayes: 0.774'''
 
    '''Score for SVM: 0.824'''
 
 
 
====Кросс-валилация и подбор параметров====
 
{{Main|Кросс-валидация}}
 
 
 
Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
 
  '''from''' sklearn.model_selection '''import''' GridSearchCV
 
  parameters = {
 
      <font color="red">'vect__ngram_range'</font>: [(<font color="blue">1</font>, <font color="blue">1</font>), (<font color="blue">1</font>, <font color="blue">2</font>)],
 
      <font color="red">'tfidf__use_idf'</font>: ('''True''', '''False'''),
 
      <font color="red">'clf__alpha'</font>: (<font color="blue">1e-2</font>, <font color="blue">1e-3</font>),
 
 
   }
 
   }
    
+
   System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);
  gs_clf = GridSearchCV(text_clf2, parameters, cv=<font color="blue">5</font>, iid='''False''', n_jobs=<font color="blue">-1</font>)
 
  gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)
 
 
 
  print(<font color="red">"Best score: %.3f"</font> % gs_clf.best_score_)
 
 
 
  '''for''' param_name '''in''' sorted(parameters.keys()):
 
    print(<font color="red">"%s: %r"</font> % (param_name, gs_clf.best_params_[param_name]))
 
 
 
  > '''Best score: 0.904'''
 
    '''clf__alpha: 0.001'''
 
    '''tfidf__use_idf: True'''
 
    '''vect__ngram_range: (1, 2)'''
 
 
 
====Метод опорных векторов (SVM)====
 
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) <sup>[на 28.01.19 не создан]</sup>}}
 
  
Загрузка датасета:
+
===Деревья решений, случайный лес===
  '''from''' sklearn '''import''' datasets
+
{{Main|Дерево решений и случайный лес#Пример на языке Java}}
  iris = datasets.load_iris()
 
  
Разбиение датасета на тестовый и тренировочный:
+
===Бустинг, Ada-boost===
  '''from''' sklearn.model_selection '''import''' train_test_split
+
{{main|Бустинг, AdaBoost#Пример на языке Java}}
  x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=<font color="blue">0.25</font>, random_state=<font color="blue">0</font>)
 
  
Построение и обучение модели:
+
===EM-алгоритм===
  clf = svm.SVC(kernel=<font color="red">'linear'</font>, C=<font color="blue">1.0</font>)
+
{{Main|EM-алгоритм|ll=EM-алгоритм <sup>[на 08.04.19 не создан]</sup>}}
  clf.fit(x_train, y_train)
+
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>
   predictions = clf.predict(x_test)
+
 +
  <dependency>
 +
    <groupId>nz.ac.waikato.cms.weka</groupId>
 +
    <artifactId>weka-stable</artifactId>
 +
    <version>3.8.0</version>
 +
   </dependency>
  
Оценка алгоритма:
+
  '''import''' weka.clusterers.ClusterEvaluation;
   '''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
+
   '''import''' weka.clusterers.EM;
   print(confusion_matrix(y_test,predictions))
+
  '''import''' weka.core.Instances;
   print(classification_report(y_test,predictions))
+
   '''import''' java.io.BufferedReader;
 +
  '''import''' java.io.FileReader;
 +
   '''import''' java.util.Random;
  
   > '''[[13  0  0]'''
+
   <font color="green">//load data</font>
    '''[ 0 15  1]'''
+
  '''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
    '''[ 0  0  9]]'''
+
   <font color="green">// new instance of clusterer</font>
                  '''precision    recall  f1-score   support'''
+
   '''var''' model = new EM();
    
+
  <font color="green">// build the clusterer</font>
              '''0      1.00      1.00      1.00        13'''
+
  model.buildClusterer(data);
              '''1      1.00      0.94      0.97        16'''
+
   System.out.println(model);
              '''2      0.90      1.00      0.95        9'''
+
  '''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));
    
 
      '''micro avg      0.97      0.97      0.97        38'''
 
      '''macro avg      0.97      0.98      0.97        38'''
 
    '''weighted avg      0.98      0.97      0.97        38'''
 
  
====EM-алгоритм====
+
===Уменьшение размерности===
{{Main|EM-алгоритм|l1=EM-алгоритм<sup>[на 28.01.19 не создан]</sup>}}
+
{{Main|Уменьшение размерности#Пример на языке Java}}
  
  '''import''' numpy '''as''' np
+
===Байесовская классификация===
  '''import''' matplotlib.pyplot '''as''' plt
+
{{Main|Байесовская классификация#Пример на языке Java}}
  '''from''' matplotlib.colors '''import''' LogNorm
 
  '''from''' sklearn '''import''' mixture
 
 
 
  n_samples = <font color="blue">300</font>
 
 
 
  <font color="green"># generate random sample, two components</font>
 
  np.random.seed(<font color="blue">0</font>)
 
 
 
  <font color="green"># generate spherical data centered on (20, 20)</font>
 
  shifted_gaussian = np.random.randn(n_samples, <font color="blue">2</font>) + np.array([<font color="blue">20</font>, <font color="blue">20</font>])
 
 
 
  <font color="green"># generate zero centered stretched Gaussian data</font>
 
  C = np.array([[<font color="blue">0.</font>, <font color="blue">-0.7</font>], [<font color="blue">3.5</font>, <font color="blue">.7</font>]])
 
  stretched_gaussian = np.dot(np.random.randn(n_samples, <font color="blue">2</font>), C)
 
 
 
  <font color="green"># concatenate the two datasets into the final training set</font>
 
  X_train = np.vstack([shifted_gaussian, stretched_gaussian])
 
 
 
  <font color="green"># fit a Gaussian Mixture Model with two components</font>
 
  clf = mixture.GaussianMixture(n_components=<font color="blue">2</font>, covariance_type=<font color="red">'full'</font>)
 
  clf.fit(X_train)
 
 
 
  <font color="green"># display predicted scores by the model as a contour plot</font>
 
  x = np.linspace(<font color="blue">-20.</font>, <font color="blue">30.</font>)
 
  y = np.linspace(<font color="blue">-20.</font>, <font color="blue">40.</font>)
 
  X, Y = np.meshgrid(x, y)
 
  XX = np.array([X.ravel(), Y.ravel()]).T
 
  Z = -clf.score_samples(XX)
 
  Z = Z.reshape(X.shape)
 
 
 
  CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=<font color="blue">1.0</font>, vmax=<font color="blue">1000.0</font>),
 
                  levels=np.logspace(<font color="blue">0</font>, <font color="blue">3</font>, <font color="blue">10</font>))
 
  CB = plt.colorbar(CS, shrink=<font color="blue">0.8</font>, extend=<font color="red">'both'</font>)
 
  plt.scatter(X_train[:, <font color="blue">0</font>], X_train[:, <font color="blue">1</font>], <font color="blue">.8</font>)
 
 
 
  plt.title(<font color="red">'Negative log-likelihood predicted by a GMM'</font>)
 
  plt.axis(<font color="red">'tight'</font>)
 
  plt.show()
 
  
[[File:Em.png|400px|none|super]]
+
===Метрический классификатор и метод ближайших соседей===
 
+
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}
====Уменьшение размерности====
 
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}
 
 
 
==Tensorflow==
 
===Описание===
 
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
 
===Примеры кода===
 
====Сверточная нейронная сеть====
 
{{Main|Сверточные нейронные сети}}
 
 
 
Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
 
  '''from''' __future__ '''import''' division, print_function, absolute_import
 
  '''import''' tensorflow '''as''' tf
 
 
 
  <font color="green"># Import MNIST data</font>
 
  '''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
 
  mnist = input_data.read_data_sets(<font color="red">"/tmp/data/"</font>, one_hot='''True''')
 
 
 
  <font color="green"># Training Parameters</font>
 
  learning_rate = <font color="blue">0.001</font>
 
  num_steps = <font color="blue">200</font>
 
  batch_size = <font color="blue">128</font>
 
  display_step = <font color="blue">10</font>
 
 
 
  <font color="green"># Network Parameters</font>
 
  num_input = <font color="blue">784</font> <font color="green"># MNIST data input (img shape: 28*28)</font>
 
  num_classes = <font color="blue">10</font> <font color="green"># MNIST total classes (0-9 digits)</font>
 
  dropout = <font color="blue">0.75</font> <font color="green"># Dropout, probability to keep units</font>
 
 
 
  <font color="green"># tf Graph input</font>
 
  X = tf.placeholder(tf.float32, ['''None''', num_input])
 
  Y = tf.placeholder(tf.float32, ['''None''', num_classes])
 
  keep_prob = tf.placeholder(tf.float32) <font color="green"># dropout (keep probability)</font>
 
 
 
  <font color="green"># Create some wrappers for simplicity</font>
 
  '''def''' conv2d(x, W, b, strides=<font color="blue">1</font>):
 
    <font color="green"># Conv2D wrapper, with bias and relu activation</font>
 
    x = tf.nn.conv2d(x, W, strides=[<font color="blue">1</font>, strides, strides, <font color="blue">1</font>], padding=<font color="red">'SAME'</font>)
 
    x = tf.nn.bias_add(x, b)
 
    '''return''' tf.nn.relu(x)
 
 
 
  '''def''' maxpool2d(x, k=<font color="blue">2</font>):
 
    <font color="green"># MaxPool2D wrapper</font>
 
    '''return''' tf.nn.max_pool(x, ksize=[<font color="blue">1</font>, k, k, <font color="blue">1</font>], strides=[<font color="blue">1</font>, k, k, <font color="blue">1</font>],
 
                          padding=<font color="red">'SAME'</font>)
 
 
 
  <font color="green"># Create model</font>
 
  '''def''' conv_net(x, weights, biases, dropout):
 
    <font color="green"># MNIST data input is a 1-D vector of 784 features (28*28 pixels)
 
    # Reshape to match picture format [Height x Width x Channel]
 
    # Tensor input become 4-D: [Batch Size, Height, Width, Channel]</font>
 
    x = tf.reshape(x, shape=[<font color="blue">-1</font>, <font color="blue">28</font>, <font color="blue">28</font>, <font color="blue">1</font>])
 
    <font color="green"># Convolution Layer</font>
 
    conv1 = conv2d(x, weights[<font color="red">'wc1'</font>], biases[<font color="red">'bc1'</font>])
 
    <font color="green"># Max Pooling (down-sampling)</font>
 
    conv1 = maxpool2d(conv1, k=<font color="blue">2</font>)
 
    <font color="green"># Convolution Layer</font>
 
    conv2 = conv2d(conv1, weights[<font color="red">'wc2'</font>], biases[<font color="red">'bc2'</font>])
 
    <font color="green"># Max Pooling (down-sampling)</font>
 
    conv2 = maxpool2d(conv2, k=<font color="blue">2</font>)
 
    <font color="green"># Fully connected layer
 
    # Reshape conv2 output to fit fully connected layer input</font>
 
    fc1 = tf.reshape(conv2, [<font color="blue">-1</font>, weights[<font color="red">'wd1'</font>].get_shape().as_list()[<font color="blue">0</font>]])
 
    fc1 = tf.add(tf.matmul(fc1, weights[<font color="red">'wd1'</font>]), biases[<font color="red">'bd1'</font>])
 
    fc1 = tf.nn.relu(fc1)
 
    <font color="green"># Apply Dropout</font>
 
    fc1 = tf.nn.dropout(fc1, dropout)
 
    <font color="green"># Output, class prediction</font>
 
    out = tf.add(tf.matmul(fc1, weights[<font color="red">'out'</font>]), biases[<font color="red">'out'</font>])
 
    '''return''' out
 
 
 
  <font color="green"># Store layers weight & bias</font>
 
  weights = {
 
    <font color="green"># 5x5 conv, 1 input, 32 outputs</font>
 
    <font color="red">'wc1'</font>: tf.Variable(tf.random_normal([<font color="blue">5</font>, <font color="blue">5</font>, <font color="blue">1</font>, <font color="blue">32</font>])),
 
    <font color="green"># 5x5 conv, 32 inputs, 64 outputs</font>
 
    <font color="red">'wc2'</font>: tf.Variable(tf.random_normal([<font color="blue">5</font>, <font color="blue">5</font>, <font color="blue">32</font>, <font color="blue">64</font>])),
 
    <font color="green"># fully connected, 7*7*64 inputs, 1024 outputs</font>
 
    <font color="red">'wd1'</font>: tf.Variable(tf.random_normal([<font color="blue">7</font>*<font color="blue">7</font>*<font color="blue">64</font>, <font color="blue">1024</font>])),
 
    <font color="green"># 1024 inputs, 10 outputs (class prediction)</font>
 
    <font color="red">'out'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>, num_classes]))
 
  }
 
 
 
  biases = {
 
    <font color="red">'bc1'</font>: tf.Variable(tf.random_normal([<font color="blue">32</font>])),
 
    <font color="red">'bc2'</font>: tf.Variable(tf.random_normal([<font color="blue">64</font>])),
 
    <font color="red">'bd1'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>])),
 
    <font color="red">'out'</font>: tf.Variable(tf.random_normal([num_classes]))
 
  }
 
 
 
  <font color="green"># Construct model</font>
 
  logits = conv_net(X, weights, biases, keep_prob)
 
  prediction = tf.nn.softmax(logits)
 
 
 
  <font color="green"># Define loss and optimizer</font>
 
  loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
 
    logits=logits, labels=Y))
 
  optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
 
  train_op = optimizer.minimize(loss_op)
 
 
 
  <font color="green"># Evaluate model</font>
 
  correct_pred = tf.equal(tf.argmax(prediction, <font color="blue">1</font>), tf.argmax(Y, <font color="blue">1</font>))
 
  accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
 
 
 
  <font color="green"># Initialize the variables (i.e. assign their default value)</font>
 
  init = tf.global_variables_initializer()
 
 
 
  <font color="green"># Start training</font>
 
  '''with''' tf.Session() '''as''' sess:
 
    <font color="green"># Run the initializer</font>
 
    sess.run(init)
 
    '''for''' step '''in''' '''range'''(<font color="blue">1</font>, num_steps+<font color="blue">1</font>):
 
      batch_x, batch_y = mnist.train.next_batch(batch_size)
 
      <font color="green"># Run optimization op (backprop)</font>
 
      sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: <font color="blue">0.8</font>})
 
      '''if''' step % display_step == <font color="blue">0</font> '''or''' step == <font color="blue">1</font>:
 
        <font color="green"># Calculate batch loss and accuracy</font>
 
        loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
 
                                                            Y: batch_y,
 
                                                            keep_prob: <font color="blue">1.0</font>})
 
        print(<font color="red">"Step "</font> + str(step) + <font color="red">", Minibatch Loss= "</font> + \
 
              <font color="red">"{:.4f}"</font>.format(loss) + <font color="red">", Training Accuracy= "</font> + \
 
              <font color="red">"{:.3f}"</font>.format(acc))
 
    print(<font color="red">"Optimization Finished!"</font>)
 
    <font color="green"># Calculate accuracy for 256 MNIST test images</font>
 
    print(<font color="red">"Testing Accuracy:"</font>, \
 
      sess.run(accuracy, feed_dict={X: mnist.test.images[:<font color="blue">256</font>],
 
                                    Y: mnist.test.labels[:<font color="blue">256</font>],
 
                                    keep_prob: <font color="blue">1.0</font>}))
 
 
 
  > '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
 
    '''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
 
    '''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
 
    '''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
 
    '''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
 
    '''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
 
    '''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
 
    '''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
 
    '''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
 
    '''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
 
    '''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
 
    '''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
 
    '''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
 
    '''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
 
    '''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
 
    '''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
 
    '''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
 
    '''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
 
    '''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
 
    '''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
 
    '''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
 
    '''Optimization Finished!'''
 
    '''Testing Accuracy: 0.94140625'''
 
 
 
==Keras==
 
===Описание===
 
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
 
===Примеры кода===
 
====Сверточная нейронная сеть====
 
{{Main|Сверточные нейронные сети}}
 
 
 
Реализация сверточной нейронной сети для классификации текста:
 
  '''from''' __future__ '''import''' print_function
 
  '''from''' keras.preprocessing '''import''' sequence
 
  '''from''' keras.models '''import''' Sequential
 
  '''from''' keras.layers '''import''' Dense, Dropout, Activation
 
  '''from''' keras.layers '''import''' Embedding
 
  '''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
 
  '''from''' keras.datasets '''import''' imdb
 
 
 
  <font color="green"># set parameters:</font>
 
  max_features = <font color="blue">5000</font>
 
  maxlen = <font color="blue">400</font>
 
  batch_size = <font color="blue">32</font>
 
  embedding_dims = <font color="blue">50</font>
 
  filters = <font color="blue">250</font>
 
  kernel_size = <font color="blue">3</font>
 
  hidden_dims = <font color="blue">250</font>
 
  epochs = <font color="blue">2</font>
 
 
 
  (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
 
  print(len(x_train), <font color="red">'train sequences'</font>)
 
  print(len(x_test), <font color="red">'test sequences'</font>)
 
 
 
  > '''25000 train sequences'''
 
    '''25000 test sequences'''
 
 
 
  print(<font color="red">'Pad sequences (samples x time)'</font>)
 
  x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
 
  x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
 
  print(<font color="red">'x_train shape:'</font>, x_train.shape)
 
  print(<font color="red">'x_test shape:'</font>, x_test.shape)
 
 
 
  > '''Pad sequences (samples x time)'''
 
    '''x_train shape: (25000, 400)'''
 
    '''x_test shape: (25000, 400)'''
 
 
 
  model = Sequential()
 
 
 
  model.add(Embedding(max_features,
 
                      embedding_dims,
 
                      input_length=maxlen))
 
  model.add(Dropout(<font color="blue">0.2</font>)) 
 
  model.add(Conv1D(filters,
 
                  kernel_size,
 
                  padding=<font color="red">'valid'</font>,
 
                  activation=<font color="red">'relu'</font>,
 
                  strides=<font color="blue">1</font>))
 
  model.add(GlobalMaxPooling1D())
 
  model.add(Dense(hidden_dims))
 
  model.add(Dropout(<font color="blue">0.2</font>))
 
  model.add(Activation(<font color="red">'relu'</font>))
 
  model.add(Dense(<font color="blue">1</font>))
 
  model.add(Activation(<font color="red">'sigmoid'</font>))
 
 
 
  model.compile(loss=<font color="red">'binary_crossentropy'</font>,
 
                optimizer=<font color="red">'adam'</font>,
 
                metrics=[<font color="red">'accuracy'</font>])
 
  model.fit(x_train, y_train,
 
            batch_size=batch_size,
 
            epochs=epochs,
 
            validation_data=(x_test, y_test))
 
 
 
  > '''Train on 25000 samples, validate on 25000 samples'''
 
    '''Epoch 1/2'''
 
    '''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
 
    '''Epoch 2/2'''
 
    '''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''
 
 
 
==Другие библиотеки для машинного обучения на Python==
 
===Вспомогательные библиотеки===
 
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц вместе с большой библиотекой  высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>;
 
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке;
 
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib;
 
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.
 
 
 
===Библиотеки для глубокого обучения===
 
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff;
 
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач;
 
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA;
 
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.
 
 
 
===Библиотеки для обработки естественного языка===
 
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python;
 
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.
 
 
 
===Библиотеки для градиентного бустинга===
 
* [[XGBoost|Xgboost]]<sup>[на 28.01.19 не создан]</sup><ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм;
 
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net;
 
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.
 
  
 
==См. также==
 
==См. также==
 
*[[:Примеры кода на Scala|Примеры кода на Scala]]
 
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]]<sup>[на 28.01.19 не создан]</sup>
+
*[[:Примеры кода на R|Примеры кода на R]]<sup>[на 08.04.19 не создан]</sup>
*[[:Примеры кода на Java|Примеры кода на Java]]
+
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]
  
==Примечания==
+
== Примечания ==
 
<references/>
 
<references/>
 
 
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]
 
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Версия 17:18, 8 апреля 2019

Популярные библиотеки

  • Weka[1] — популярная библиотека, написанная на языке Java и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
  • Smile[2]Java фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. Smile покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
  • deeplearning4j[3]Java библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.

Примеры кода

Для работы с приведенными ниже примерами необходим JDK версии не ниже 10 и система сборки Maven.
Каждый пример структурирован следующим образом:

  1. Maven зависимость на необходимые библиотеки
  2. Список необходимых import директив
  3. Код примера с комментариями

Вариации регрессии

Основная статья: Вариации регрессии

Линейная регрессия

Основная статья: Линейная регрессия

Пример линейной регресии с применением weka.classifiers.functions.LinearRegression[4]

 <dependency>
   <groupId>nz.ac.waikato.cms.weka</groupId>
   <artifactId>weka-stable</artifactId>
   <version>3.8.0</version>
 </dependency>
 import weka.classifiers.functions.LinearRegression;
 import weka.core.Instance;
 import weka.core.Instances;
 //Load Data set
 var data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
 data.setClassIndex(data.numAttributes() - 1);
 //Build model
 var model = new LinearRegression();
 try { model.buildClassifier(data); }
 catch (Exception e) { e.printStackTrace(); }
 //output model
 System.out.printf("model parameters: %s%n", model);
 // Now Predicting the cost
 var myHouse = data.lastInstance();
 var price  = model.classifyInstance(myHouse);
 System.out.printf("predicted price = %s%n", price)

Логистическая регрессиия

Основная статья: Логистическая регрессия

Пример линейной регрессии с применением smile.classification.LogisticRegression[5]

 <dependency>
   <groupId>com.github.haifengl</groupId>
   <artifactId>smile-core</artifactId>
   <version>1.5.2</version>
 </dependency>
 import smile.data.AttributeDataset;
 import smile.data.NominalAttribute;
 import smile.classification.LogisticRegression;
 import smile.data.parser.ArffParser;
 var arffParser = new ArffParser();
 arffParser.setResponseIndex(4);
 var iris   = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
 var logClf = new LogisticRegression(iris.x(), iris.labels());
 logClf.predict(testX);

Гребневая регрессия (ридж-регрессия)

Пример гребневой регрессии с применением smile.regression.RidgeRegression[6]

 <dependency>
   <groupId>com.github.haifengl</groupId>
   <artifactId>smile-core</artifactId>
   <version>1.5.2</version>
 </dependency>
 import smile.data.NominalAttribute;
 import smile.data.parser.DelimitedTextParser;
 import smile.regression.RidgeRegression;
 var parser = new DelimitedTextParser();
 parser.setDelimiter(", ");
 parser.setResponseIndex(new NominalAttribute("class"), 0);
 var dataset  = parser.parse("dataset.csv");
 var lambda   = 0.0057d;
 var ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
 ridgeClf.predict(testX);

Лассо-регрессия

Пример Лассо-регрессии с применением smile.regression.LASSO[7]

 <dependency>
   <groupId>com.github.haifengl</groupId>
   <artifactId>smile-core</artifactId>
   <version>1.5.2</version>
 </dependency>
 import smile.data.NominalAttribute;
 import smile.data.parser.DelimitedTextParser;
 import smile.regression.LASSO;
 var parser = new DelimitedTextParser();
 parser.setDelimiter(", ");
 parser.setResponseIndex(new NominalAttribute("class"), 0);
 var dataset = parser.parse("dataset.csv");
 var lasso   = new LASSO(dataset.x(), dataset.y(), 10);
 lasso.predict(testX);

Классификация при помощи MLP

Пример классификации с применением weka.classifiers.functions.MultilayerPerceptron[8]

 <dependency>
   <groupId>nz.ac.waikato.cms.weka</groupId>
   <artifactId>weka-stable</artifactId>
   <version>3.8.0</version>
 </dependency>
 import weka.classifiers.functions.MultilayerPerceptron;
 import weka.core.converters.CSVLoader;
 import java.io.File;
 // read train & test datasets and build MLP classifier
 var trainds = new DataSource("etc/train.csv");
 var train   = trainds.getDataSet();
 train.setClassIndex(train.numAttributes() - 1);
 var testds = new DataSource("etc/test.csv");
 var test   = testds.getDataSet();
 test.setClassIndex(test.numAttributes() - 1);
 var mlp = new MultilayerPerceptron();
 mlp.buildClassifier(train);
 // Test the model
 var eTest = new Evaluation(train);
 eTest.evaluateModel(mlp, test);
 // Print the result à la Weka explorer:
 var strSummary = eTest.toSummaryString();
 System.out.println(strSummary);

Рекуррентные нейронные сети

Пример простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки deeplearning4j.

Долгая краткосрочная память

Пример реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки deeplearning4j.

Метод опорных векторов

Пример классификации с применением smile.classification.SVM[9]

 <dependency>
   <groupId>com.github.haifengl</groupId>
   <artifactId>smile-core</artifactId>
   <version>1.5.2</version>
 </dependency>
 import smile.classification.SVM;
 import smile.data.NominalAttribute;
 import smile.data.parser.DelimitedTextParser;
 import smile.math.kernel.GaussianKernel;
 import java.util.Arrays;
 // read train & test dataset
 var parser = new DelimitedTextParser();
 parser.setResponseIndex(new NominalAttribute("class"), 0);
 var train   = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
 var test    = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
 var classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
 // build SVM classifier
 var svm     = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
 svm.learn(train.x(), train.labels());
 svm.finish();
 // calculate test error rate
 var error = 0;
 for (int i = 0; i < test.x().length; i++) {
  if (svm.predict(test.x()[i]) != test.labels()[i]) {
    error++;
   }
 }
 System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

Деревья решений, случайный лес

Бустинг, Ada-boost

EM-алгоритм

Основная статья: EM-алгоритм

Пример кластеризации с применением weka.clusterers.EM[10]

 <dependency>
   <groupId>nz.ac.waikato.cms.weka</groupId>
   <artifactId>weka-stable</artifactId>
   <version>3.8.0</version>
 </dependency>
 import weka.clusterers.ClusterEvaluation;
 import weka.clusterers.EM;
 import weka.core.Instances;
 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.util.Random;
 //load data
 var data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
 // new instance of clusterer
 var model = new EM();
 // build the clusterer
 model.buildClusterer(data);
 System.out.println(model);
 var logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

Уменьшение размерности

Байесовская классификация

Метрический классификатор и метод ближайших соседей

См. также

Примечания