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

Материал из Викиконспекты
Перейти к: навигация, поиск
(Сверточная нейронная сеть)
м (rollbackEdits.php mass rollback)
 
(не показано 57 промежуточных версий 7 участников)
Строка 3: Строка 3:
 
==Scikit-learn==
 
==Scikit-learn==
 
===Описание===
 
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение кросс-валидации. В библиотеке также есть основные алгоритмы машинного обучения: линейной регрессии, (и ее модификаций Лассо, гребневой регрессии), опорных векторов, решающих деревьев и лесов и др. Есть и реализации основных методов кластеризации. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с параметрами (фичами): например, понижение размерности методом главных компонент. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.
+
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>, позволяющая работать с разбалансированными выборками и генерировать новые значения.
 +
 
 
===Примеры кода===
 
===Примеры кода===
 +
====Линейная регрессия====
 +
{{Main|Линейная регрессия|l1=Линейная регрессия<sup>[на 28.01.19 не создан]</sup>}}
 +
 +
  <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]]
 +
 
====Логистическая регрессия====
 
====Логистическая регрессия====
Основная статья: [[Логистическая регрессия]]
+
{{Main|Логистическая регрессия}}
  
 
Загрузка датасета:
 
Загрузка датасета:
   from sklearn.datasets import load_digits
+
   '''from''' sklearn.datasets '''import''' load_digits
 
   digits = load_digits()
 
   digits = load_digits()
  
 
Вывод первых трех тренировочных данных для визуализации:
 
Вывод первых трех тренировочных данных для визуализации:
   import numpy as np
+
   '''import''' numpy '''as''' np
   import matplotlib.pyplot as plt
+
   '''import''' matplotlib.pyplot '''as''' plt
 
    
 
    
   plt.figure(figsize=(20,4))
+
   plt.figure(figsize=(<font color="blue">20</font>,<font color="blue">4</font>))
   for index, (image, label) in enumerate(zip(digits.data[0:3], digits.target[0:3])):
+
   '''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>])):
     plt.subplot(1, 3, index + 1)
+
     plt.subplot(<font color="blue">1</font>, <font color="blue">3</font>, index + <font color="blue">1</font>)
     plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
+
     plt.imshow(np.reshape(image, (<font color="blue">8</font>,<font color="blue">8</font>)), cmap=plt.cm.gray)
     plt.title('Training: %i\n' % label, fontsize = 20)
+
     plt.title(<font color="red">'Training: %i\n'</font> % label, fontsize = <font color="blue">20</font>)
 +
 
 +
[[File:Digits-sklearn.png|800px|none|super]]
  
 
Разбиение датасета на тренировочный и тестовый:
 
Разбиение датасета на тренировочный и тестовый:
   from sklearn.model_selection import train_test_split
+
   '''from''' sklearn.model_selection '''import''' train_test_split
   x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)
+
   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>)
  
 
Построение и обучение модели:
 
Построение и обучение модели:
   from sklearn.linear_model import LogisticRegression
+
   '''from''' sklearn.linear_model '''import''' LogisticRegression
 
   lr = LogisticRegression()
 
   lr = LogisticRegression()
 
   lr.fit(x_train, y_train)
 
   lr.fit(x_train, y_train)
 
   predictions = lr.predict(x_test)
 
   predictions = lr.predict(x_test)
 +
 +
Оценка алгоритма:
 +
  score = lr.score(x_test, y_test)
 +
  print(<font color="red">"Score: %.3f"</font> % score)
 +
 +
  > '''Score: 0.953'''
 +
 
====Перцептрон====
 
====Перцептрон====
Основная статья: [[Нейронные сети, перцептрон]]
+
{{Main|Нейронные сети, перцептрон}}
  
 
Загрузка датасета:
 
Загрузка датасета:
   from sklearn import datasets
+
   '''from''' sklearn '''import''' datasets
 
   iris = datasets.load_iris()
 
   iris = datasets.load_iris()
 
   X = iris.data
 
   X = iris.data
Строка 41: Строка 99:
  
 
Разбиение датасета на тренировочный и тестовый:
 
Разбиение датасета на тренировочный и тестовый:
   from sklearn.model_selection import train_test_split
+
   '''from''' sklearn.model_selection '''import''' train_test_split
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
+
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = <font color="blue">0.20</font>)
  
 
Трансформация признаков:
 
Трансформация признаков:
   from sklearn.preprocessing import StandardScaler
+
   '''from''' sklearn.preprocessing '''import''' StandardScaler
 
   scaler = StandardScaler()
 
   scaler = StandardScaler()
 
   scaler.fit(X_train)
 
   scaler.fit(X_train)
Строка 52: Строка 110:
  
 
Построение и обучение модели:
 
Построение и обучение модели:
   from sklearn.neural_network import MLPClassifier
+
   '''from''' sklearn.neural_network '''import''' MLPClassifier
   mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
+
   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>)
 
   mlp.fit(X_train, y_train.values.ravel())
 
   mlp.fit(X_train, y_train.values.ravel())
 
   predictions = mlp.predict(X_test)
 
   predictions = mlp.predict(X_test)
  
 
Оценка алгоритма:
 
Оценка алгоритма:
   from sklearn.metrics import classification_report, confusion_matrix
+
   '''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
 +
  print(confusion_matrix(y_test,predictions))
 +
  print(classification_report(y_test,predictions))
 +
 
 +
  > '''[[ 7  0  0]'''
 +
    '''[ 0  8  1]'''
 +
    '''[ 0  2 12]]'''
 +
                  '''precision    recall  f1-score  support'''
 +
 
 +
              '''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'''
 +
 
 +
====Метрический классификатор и метод ближайших соседей====
 +
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}
 +
 
 +
====Дерево решений и случайный лес====
 +
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}
 +
 
 +
====Обработка естественного языка====
 +
{{Main|Обработка естественного языка}}
 +
 
 +
Загрузка датасета:
 +
  '''from''' sklearn '''import''' fetch_20newsgroups
 +
  twenty_train = fetch_20newsgroups(subset=<font color="red">'train'</font>, shuffle='''True''', random_state=<font color="blue">42</font>)
 +
 
 +
Вывод первых трех строк первого тренивочного файла и его класса:
 +
  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>]))
 +
  print(twenty_train.target_names[twenty_train.target[<font color="blue">0</font>]])
 +
 
 +
  > '''From: lerxst@wam.umd.edu (where's my thing)'''
 +
    '''Subject: WHAT car is this!?'''
 +
    '''Nntp-Posting-Host: rac3.wam.umd.edu'''
 +
 
 +
    '''rec.autos'''
 +
 
 +
Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]]<sup>[на 28.01.19 не создан]</sup>, а вторая использует метод опорных векторов:
 +
  '''from''' sklearn.pipeline '''import''' Pipeline
 +
  '''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer
 +
 
 +
  '''from''' sklearn.naive_bayes '''import''' MultinomialNB
 +
  text_clf1 = Pipeline([
 +
    (<font color="red">'vect'</font>, CountVectorizer()),
 +
    (<font color="red">'tfidf'</font>, TfidfTransformer()),
 +
    (<font color="red">'clf'</font>, MultinomialNB()),
 +
  ])
 +
 
 +
  '''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>),
 +
  }
 +
 
 +
  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
 +
  iris = datasets.load_iris()
 +
 
 +
Разбиение датасета на тестовый и тренировочный:
 +
  '''from''' sklearn.model_selection '''import''' train_test_split
 +
  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>)
 +
 
 +
Построение и обучение модели:
 +
  clf = svm.SVC(kernel=<font color="red">'linear'</font>, C=<font color="blue">1.0</font>)
 +
  clf.fit(x_train, y_train)
 +
  predictions = clf.predict(x_test)
 +
 
 +
Оценка алгоритма:
 +
  '''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
 
   print(confusion_matrix(y_test,predictions))
 
   print(confusion_matrix(y_test,predictions))
 
   print(classification_report(y_test,predictions))
 
   print(classification_report(y_test,predictions))
==Theano==
 
===Описание===
 
Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач.
 
===Примеры кода===
 
====Логистическая регрессия====
 
Основная статья: [[Логистическая регрессия]].
 
  
Реализация логистической регрессии для классификации цифр из датасета MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>:
+
  > '''[[13  0  0]'''
   from __future__ import print_function
+
    '''[ 0 15  1]'''
   __docformat__ = 'restructedtext en'
+
    '''[ 0  0  9]]'''
  import six.moves.cPickle as pickle
+
                  '''precision    recall  f1-score  support'''
   import gzip
+
 
   import os
+
              '''0      1.00      1.00      1.00        13'''
   import sys
+
              '''1      1.00      0.94      0.97        16'''
   import timeit
+
              '''2      0.90      1.00      0.95        9'''
   import numpy
+
 
   import theano
+
      '''micro avg      0.97      0.97      0.97        38'''
   import theano.tensor as T
+
      '''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>}}
 +
 
 +
   '''import''' numpy '''as''' np
 +
   '''import''' matplotlib.pyplot '''as''' plt
 +
   '''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>])
 
    
 
    
   class LogisticRegression(object):
+
   <font color="green"># generate zero centered stretched Gaussian data</font>
    def __init__(self, input, n_in, n_out):
+
  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>]])
      self.W = theano.shared(
+
  stretched_gaussian = np.dot(np.random.randn(n_samples, <font color="blue">2</font>), C)
        value=numpy.zeros(
 
          (n_in, n_out),
 
          dtype=theano.config.floatX
 
        ),
 
        name='W',
 
        borrow=True
 
      )
 
      self.b = theano.shared(
 
        value=numpy.zeros(
 
          (n_out,),
 
          dtype=theano.config.floatX
 
        ),
 
        name='b',
 
        borrow=True
 
      )
 
      self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
 
      self.y_pred = T.argmax(self.p_y_given_x, axis=1)
 
      self.params = [self.W, self.b]
 
      self.input = input
 
    def negative_log_likelihood(self, y):
 
      return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])
 
 
    
 
    
   def load_data(dataset):
+
   <font color="green"># concatenate the two datasets into the final training set</font>
    data_dir, data_file = os.path.split(dataset)
+
  X_train = np.vstack([shifted_gaussian, stretched_gaussian])
    if data_dir == "" and not os.path.isfile(dataset):
 
      new_path = os.path.join(
 
        os.path.split(__file__)[0],
 
        "..",
 
        "data",
 
        dataset
 
      )
 
      if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz':
 
        dataset = new_path
 
    if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz':
 
      from six.moves import urllib
 
      origin = (
 
        'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz'
 
      )
 
      print('Downloading data from %s' % origin)
 
      urllib.request.urlretrieve(origin, dataset)
 
    with gzip.open(dataset, 'rb') as f:
 
      try:
 
        train_set, valid_set, test_set = pickle.load(f, encoding='latin1')
 
      except:
 
        train_set, valid_set, test_set = pickle.load(f)
 
    def shared_dataset(data_xy, borrow=True):
 
      data_x, data_y = data_xy
 
      shared_x = theano.shared(numpy.asarray(data_x,
 
                                            dtype=theano.config.floatX),
 
                              borrow=borrow)
 
      shared_y = theano.shared(numpy.asarray(data_y,
 
                                            dtype=theano.config.floatX),
 
                              borrow=borrow)
 
      return shared_x, T.cast(shared_y, 'int32')
 
    test_set_x, test_set_y = shared_dataset(test_set)
 
    valid_set_x, valid_set_y = shared_dataset(valid_set)
 
    train_set_x, train_set_y = shared_dataset(train_set)
 
    rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
 
            (test_set_x, test_set_y)]
 
    return rval
 
 
    
 
    
   def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000,
+
   <font color="green"># fit a Gaussian Mixture Model with two components</font>
                            dataset='mnist.pkl.gz',
+
  clf = mixture.GaussianMixture(n_components=<font color="blue">2</font>, covariance_type=<font color="red">'full'</font>)
                            batch_size=600):
+
  clf.fit(X_train)
    datasets = load_data(dataset)
 
    train_set_x, train_set_y = datasets[0]
 
    valid_set_x, valid_set_y = datasets[1]
 
    test_set_x, test_set_y = datasets[2]
 
    n_train_batches = train_set_x.get_value(borrow=True).shape[0]
 
    n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]
 
    n_test_batches = test_set_x.get_value(borrow=True).shape[0]
 
    index = T.lscalar()
 
    x = T.matrix('x')
 
    y = T.ivector('y')
 
    classifier = LogisticRegression(input=x, n_in=28 * 28, n_out=10)
 
    cost = classifier.negative_log_likelihood(y)
 
    test_model = theano.function(
 
        inputs=[index],
 
        outputs=classifier.errors(y),
 
        givens={
 
            x: test_set_x[index * batch_size: (index + 1) * batch_size],
 
            y: test_set_y[index * batch_size: (index + 1) * batch_size]
 
        }
 
    )
 
    validate_model = theano.function(
 
        inputs=[index],
 
        outputs=classifier.errors(y),
 
        givens={
 
            x: valid_set_x[index * batch_size: (index + 1) * batch_size],
 
            y: valid_set_y[index * batch_size: (index + 1) * batch_size]
 
        }
 
    )
 
    g_W = T.grad(cost=cost, wrt=classifier.W)
 
    g_b = T.grad(cost=cost, wrt=classifier.b)
 
    updates = [(classifier.W, classifier.W - learning_rate * g_W),
 
              (classifier.b, classifier.b - learning_rate * g_b)]
 
    train_model = theano.function(
 
        inputs=[index],
 
        outputs=cost,
 
        updates=updates,
 
        givens={
 
            x: train_set_x[index * batch_size: (index + 1) * batch_size],
 
            y: train_set_y[index * batch_size: (index + 1) * batch_size]
 
        }
 
    )
 
    patience = 5000
 
    patience_increase = 2
 
    improvement_threshold = 0.995
 
    validation_frequency = min(n_train_batches, patience // 2)
 
    best_validation_loss = numpy.inf
 
    test_score = 0.
 
    start_time = timeit.default_timer()
 
    done_looping = False
 
    epoch = 0
 
    while (epoch < n_epochs) and (not done_looping):
 
        epoch = epoch + 1
 
        for minibatch_index in range(n_train_batches):
 
            minibatch_avg_cost = train_model(minibatch_index)
 
            iter = (epoch - 1) * n_train_batches + minibatch_index
 
            if (iter + 1) % validation_frequency == 0:
 
                validation_losses = [validate_model(i)
 
                                    for i in range(n_valid_batches)]
 
                this_validation_loss = numpy.mean(validation_losses)
 
                print(
 
                    'epoch %i, minibatch %i/%i, validation error %f %%' %
 
                    (
 
                        epoch,
 
                        minibatch_index + 1,
 
                        n_train_batches,
 
                        this_validation_loss * 100.
 
                    )
 
                )
 
                if this_validation_loss < best_validation_loss:
 
                    if this_validation_loss < best_validation_loss *  \
 
                      improvement_threshold:
 
                        patience = max(patience, iter * patience_increase)
 
                    best_validation_loss = this_validation_loss
 
                    test_losses = [test_model(i)
 
                                  for i in range(n_test_batches)]
 
                    test_score = numpy.mean(test_losses)
 
                    print(
 
                        (
 
                            '    epoch %i, minibatch %i/%i, test error of'
 
                            ' best model %f %%'
 
                        ) %
 
                        (
 
                            epoch,
 
                            minibatch_index + 1,
 
                            n_train_batches,
 
                            test_score * 100.
 
                        )
 
                    )
 
                    with open('best_model.pkl', 'wb') as f:
 
                        pickle.dump(classifier, f)
 
            if patience <= iter:
 
                done_looping = True
 
                break
 
    end_time = timeit.default_timer()
 
    print(
 
        (
 
            'Optimization complete with best validation score of %f %%,'
 
            'with test performance %f %%'
 
        )
 
        % (best_validation_loss * 100., test_score * 100.)
 
    )
 
    print('The code run for %d epochs, with %f epochs/sec' % (
 
        epoch, 1. * epoch / (end_time - start_time)))
 
    print(('The code for file ' +
 
          os.path.split(__file__)[1] +
 
          ' ran for %.1fs' % ((end_time - start_time))), file=sys.stderr)
 
 
    
 
    
   def predict():
+
   <font color="green"># display predicted scores by the model as a contour plot</font>
    classifier = pickle.load(open('best_model.pkl'))
+
  x = np.linspace(<font color="blue">-20.</font>, <font color="blue">30.</font>)
    predict_model = theano.function(
+
  y = np.linspace(<font color="blue">-20.</font>, <font color="blue">40.</font>)
        inputs=[classifier.input],
+
  X, Y = np.meshgrid(x, y)
        outputs=classifier.y_pred)
+
  XX = np.array([X.ravel(), Y.ravel()]).T
    dataset='mnist.pkl.gz'
+
  Z = -clf.score_samples(XX)
    datasets = load_data(dataset)
+
  Z = Z.reshape(X.shape)
    test_set_x, test_set_y = datasets[2]
 
    test_set_x = test_set_x.get_value()
 
    predicted_values = predict_model(test_set_x[:10])
 
    print("Predicted values for the first 10 examples in test set:")
 
    print(predicted_values)
 
 
    
 
    
   if __name__ == '__main__':
+
   CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=<font color="blue">1.0</font>, vmax=<font color="blue">1000.0</font>),
    sgd_optimization_mnist()
+
                  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|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}
 +
 
 
==Tensorflow==
 
==Tensorflow==
 
===Описание===
 
===Описание===
Строка 274: Строка 302:
 
===Примеры кода===
 
===Примеры кода===
 
====Сверточная нейронная сеть====
 
====Сверточная нейронная сеть====
Основная статья: [[Сверточные нейронные сети]].
+
{{Main|Сверточные нейронные сети}}
  
 
Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
 
Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
   from __future__ import division, print_function, absolute_import
+
   '''from''' __future__ '''import''' division, print_function, absolute_import
   import tensorflow as tf
+
   '''import''' tensorflow '''as''' tf
 
    
 
    
   # Import MNIST data
+
   <font color="green"># Import MNIST data</font>
   from tensorflow.examples.tutorials.mnist import input_data
+
   '''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
   mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
+
   mnist = input_data.read_data_sets(<font color="red">"/tmp/data/"</font>, one_hot='''True''')
 
    
 
    
   # Training Parameters
+
   <font color="green"># Training Parameters</font>
   learning_rate = 0.001
+
   learning_rate = <font color="blue">0.001</font>
   num_steps = 200
+
   num_steps = <font color="blue">200</font>
   batch_size = 128
+
   batch_size = <font color="blue">128</font>
   display_step = 10
+
   display_step = <font color="blue">10</font>
 
    
 
    
   # Network Parameters
+
   <font color="green"># Network Parameters</font>
   num_input = 784 # MNIST data input (img shape: 28*28)
+
   num_input = <font color="blue">784</font> <font color="green"># MNIST data input (img shape: 28*28)</font>
   num_classes = 10 # MNIST total classes (0-9 digits)
+
   num_classes = <font color="blue">10</font> <font color="green"># MNIST total classes (0-9 digits)</font>
   dropout = 0.75 # Dropout, probability to keep units
+
   dropout = <font color="blue">0.75</font> <font color="green"># Dropout, probability to keep units</font>
 
    
 
    
   # tf Graph input
+
   <font color="green"># tf Graph input</font>
   X = tf.placeholder(tf.float32, [None, num_input])
+
   X = tf.placeholder(tf.float32, ['''None''', num_input])
   Y = tf.placeholder(tf.float32, [None, num_classes])
+
   Y = tf.placeholder(tf.float32, ['''None''', num_classes])
   keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)
+
   keep_prob = tf.placeholder(tf.float32) <font color="green"># dropout (keep probability)</font>
 
    
 
    
   # Create some wrappers for simplicity
+
   <font color="green"># Create some wrappers for simplicity</font>
   def conv2d(x, W, b, strides=1):
+
   '''def''' conv2d(x, W, b, strides=<font color="blue">1</font>):
     # Conv2D wrapper, with bias and relu activation
+
     <font color="green"># Conv2D wrapper, with bias and relu activation</font>
     x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
+
     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)
 
     x = tf.nn.bias_add(x, b)
     return tf.nn.relu(x)
+
     '''return''' tf.nn.relu(x)
 
    
 
    
   def maxpool2d(x, k=2):
+
   '''def''' maxpool2d(x, k=<font color="blue">2</font>):
     # MaxPool2D wrapper
+
     <font color="green"># MaxPool2D wrapper</font>
     return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
+
     '''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='SAME')
+
                           padding=<font color="red">'SAME'</font>)
 
    
 
    
   # Create model
+
   <font color="green"># Create model</font>
   def conv_net(x, weights, biases, dropout):
+
   '''def''' conv_net(x, weights, biases, dropout):
     # MNIST data input is a 1-D vector of 784 features (28*28 pixels)
+
     <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]
 
     # Reshape to match picture format [Height x Width x Channel]
     # Tensor input become 4-D: [Batch Size, Height, Width, Channel]
+
     # Tensor input become 4-D: [Batch Size, Height, Width, Channel]</font>
     x = tf.reshape(x, shape=[-1, 28, 28, 1])
+
     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>])
     # Convolution Layer
+
     <font color="green"># Convolution Layer</font>
     conv1 = conv2d(x, weights['wc1'], biases['bc1'])
+
     conv1 = conv2d(x, weights[<font color="red">'wc1'</font>], biases[<font color="red">'bc1'</font>])
     # Max Pooling (down-sampling)
+
     <font color="green"># Max Pooling (down-sampling)</font>
     conv1 = maxpool2d(conv1, k=2)
+
     conv1 = maxpool2d(conv1, k=<font color="blue">2</font>)
     # Convolution Layer
+
     <font color="green"># Convolution Layer</font>
     conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
+
     conv2 = conv2d(conv1, weights[<font color="red">'wc2'</font>], biases[<font color="red">'bc2'</font>])
     # Max Pooling (down-sampling)
+
     <font color="green"># Max Pooling (down-sampling)</font>
     conv2 = maxpool2d(conv2, k=2)
+
     conv2 = maxpool2d(conv2, k=<font color="blue">2</font>)
     # Fully connected layer
+
     <font color="green"># Fully connected layer
     # Reshape conv2 output to fit fully connected layer input
+
     # Reshape conv2 output to fit fully connected layer input</font>
     fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
+
     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['wd1']), biases['bd1'])
+
     fc1 = tf.add(tf.matmul(fc1, weights[<font color="red">'wd1'</font>]), biases[<font color="red">'bd1'</font>])
 
     fc1 = tf.nn.relu(fc1)
 
     fc1 = tf.nn.relu(fc1)
     # Apply Dropout
+
     <font color="green"># Apply Dropout</font>
 
     fc1 = tf.nn.dropout(fc1, dropout)
 
     fc1 = tf.nn.dropout(fc1, dropout)
     # Output, class prediction
+
     <font color="green"># Output, class prediction</font>
     out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
+
     out = tf.add(tf.matmul(fc1, weights[<font color="red">'out'</font>]), biases[<font color="red">'out'</font>])
     return out
+
     '''return''' out
 
    
 
    
   # Store layers weight & bias
+
   <font color="green"># Store layers weight & bias</font>
 
   weights = {
 
   weights = {
     # 5x5 conv, 1 input, 32 outputs
+
     <font color="green"># 5x5 conv, 1 input, 32 outputs</font>
     'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
+
     <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>])),
     # 5x5 conv, 32 inputs, 64 outputs
+
     <font color="green"># 5x5 conv, 32 inputs, 64 outputs</font>
     'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
+
     <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>])),
     # fully connected, 7*7*64 inputs, 1024 outputs
+
     <font color="green"># fully connected, 7*7*64 inputs, 1024 outputs</font>
     'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
+
     <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>])),
     # 1024 inputs, 10 outputs (class prediction)
+
     <font color="green"># 1024 inputs, 10 outputs (class prediction)</font>
     'out': tf.Variable(tf.random_normal([1024, num_classes]))
+
     <font color="red">'out'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>, num_classes]))
 
   }
 
   }
 
    
 
    
 
   biases = {
 
   biases = {
     'bc1': tf.Variable(tf.random_normal([32])),
+
     <font color="red">'bc1'</font>: tf.Variable(tf.random_normal([<font color="blue">32</font>])),
     'bc2': tf.Variable(tf.random_normal([64])),
+
     <font color="red">'bc2'</font>: tf.Variable(tf.random_normal([<font color="blue">64</font>])),
     'bd1': tf.Variable(tf.random_normal([1024])),
+
     <font color="red">'bd1'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>])),
     'out': tf.Variable(tf.random_normal([num_classes]))
+
     <font color="red">'out'</font>: tf.Variable(tf.random_normal([num_classes]))
 
   }
 
   }
 
    
 
    
   # Construct model
+
   <font color="green"># Construct model</font>
 
   logits = conv_net(X, weights, biases, keep_prob)
 
   logits = conv_net(X, weights, biases, keep_prob)
 
   prediction = tf.nn.softmax(logits)
 
   prediction = tf.nn.softmax(logits)
 
    
 
    
   # Define loss and optimizer
+
   <font color="green"># Define loss and optimizer</font>
 
   loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
 
   loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
 
     logits=logits, labels=Y))
 
     logits=logits, labels=Y))
Строка 366: Строка 394:
 
   train_op = optimizer.minimize(loss_op)
 
   train_op = optimizer.minimize(loss_op)
 
    
 
    
   # Evaluate model
+
   <font color="green"># Evaluate model</font>
   correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
+
   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))
 
   accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
 
    
 
    
   # Initialize the variables (i.e. assign their default value)
+
   <font color="green"># Initialize the variables (i.e. assign their default value)</font>
 
   init = tf.global_variables_initializer()
 
   init = tf.global_variables_initializer()
 
    
 
    
   # Start training
+
   <font color="green"># Start training</font>
   with tf.Session() as sess:
+
   '''with''' tf.Session() '''as''' sess:
     # Run the initializer
+
     <font color="green"># Run the initializer</font>
 
     sess.run(init)
 
     sess.run(init)
     for step in range(1, num_steps+1):
+
     '''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)
 
       batch_x, batch_y = mnist.train.next_batch(batch_size)
       # Run optimization op (backprop)
+
       <font color="green"># Run optimization op (backprop)</font>
       sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
+
       sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: <font color="blue">0.8</font>})
       if step % display_step == 0 or step == 1:
+
       '''if''' step % display_step == <font color="blue">0</font> '''or''' step == <font color="blue">1</font>:
         # Calculate batch loss and accuracy
+
         <font color="green"># Calculate batch loss and accuracy</font>
 
         loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
 
         loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
 
                                                             Y: batch_y,
 
                                                             Y: batch_y,
                                                             keep_prob: 1.0})
+
                                                             keep_prob: <font color="blue">1.0</font>})
         print("Step " + str(step) + ", Minibatch Loss= " + \
+
         print(<font color="red">"Step "</font> + str(step) + <font color="red">", Minibatch Loss= "</font> + \
               "{:.4f}".format(loss) + ", Training Accuracy= " + \
+
               <font color="red">"{:.4f}"</font>.format(loss) + <font color="red">", Training Accuracy= "</font> + \
               "{:.3f}".format(acc))
+
               <font color="red">"{:.3f}"</font>.format(acc))
     print("Optimization Finished!")
+
     print(<font color="red">"Optimization Finished!"</font>)
     # Calculate accuracy for 256 MNIST test images
+
     <font color="green"># Calculate accuracy for 256 MNIST test images</font>
     print("Testing Accuracy:", \
+
     print(<font color="red">"Testing Accuracy:"</font>, \
       sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
+
       sess.run(accuracy, feed_dict={X: mnist.test.images[:<font color="blue">256</font>],
                                     Y: mnist.test.labels[:256],
+
                                     Y: mnist.test.labels[:<font color="blue">256</font>],
                                     keep_prob: 1.0}))
+
                                     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==
Строка 401: Строка 453:
 
===Примеры кода===
 
===Примеры кода===
 
====Сверточная нейронная сеть====
 
====Сверточная нейронная сеть====
Основная статья: [[Сверточные нейронные сети]].
+
{{Main|Сверточные нейронные сети}}
  
 
Реализация сверточной нейронной сети для классификации текста:
 
Реализация сверточной нейронной сети для классификации текста:
   from __future__ import print_function
+
   '''from''' __future__ '''import''' print_function
   from keras.preprocessing import sequence
+
   '''from''' keras.preprocessing '''import''' sequence
   from keras.models import Sequential
+
   '''from''' keras.models '''import''' Sequential
   from keras.layers import Dense, Dropout, Activation
+
   '''from''' keras.layers '''import''' Dense, Dropout, Activation
   from keras.layers import Embedding
+
   '''from''' keras.layers '''import''' Embedding
   from keras.layers import Conv1D, GlobalMaxPooling1D
+
   '''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
   from keras.datasets import imdb
+
   '''from''' keras.datasets '''import''' imdb
 
    
 
    
   # set parameters:
+
   <font color="green"># set parameters:</font>
   max_features = 5000
+
   max_features = <font color="blue">5000</font>
   maxlen = 400
+
   maxlen = <font color="blue">400</font>
   batch_size = 32
+
   batch_size = <font color="blue">32</font>
   embedding_dims = 50
+
   embedding_dims = <font color="blue">50</font>
   filters = 250
+
   filters = <font color="blue">250</font>
   kernel_size = 3
+
   kernel_size = <font color="blue">3</font>
   hidden_dims = 250
+
   hidden_dims = <font color="blue">250</font>
   epochs = 2
+
   epochs = <font color="blue">2</font>
 
    
 
    
 
   (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
 
   (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
   print(len(x_train), 'train sequences')
+
   print(len(x_train), <font color="red">'train sequences'</font>)
   print(len(x_test), 'test sequences')
+
   print(len(x_test), <font color="red">'test sequences'</font>)
    
+
 
   print('Pad sequences (samples x time)')
+
   > '''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_train = sequence.pad_sequences(x_train, maxlen=maxlen)
 
   x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
 
   x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
   print('x_train shape:', x_train.shape)
+
   print(<font color="red">'x_train shape:'</font>, x_train.shape)
   print('x_test shape:', x_test.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 = Sequential()
 
    
 
    
Строка 437: Строка 496:
 
                       embedding_dims,
 
                       embedding_dims,
 
                       input_length=maxlen))
 
                       input_length=maxlen))
   model.add(Dropout(0.2))   
+
   model.add(Dropout(<font color="blue">0.2</font>))   
 
   model.add(Conv1D(filters,
 
   model.add(Conv1D(filters,
 
                   kernel_size,
 
                   kernel_size,
                   padding='valid',
+
                   padding=<font color="red">'valid'</font>,
                   activation='relu',
+
                   activation=<font color="red">'relu'</font>,
                   strides=1))
+
                   strides=<font color="blue">1</font>))
 
   model.add(GlobalMaxPooling1D())
 
   model.add(GlobalMaxPooling1D())
 
   model.add(Dense(hidden_dims))
 
   model.add(Dense(hidden_dims))
   model.add(Dropout(0.2))
+
   model.add(Dropout(<font color="blue">0.2</font>))
   model.add(Activation('relu'))
+
   model.add(Activation(<font color="red">'relu'</font>))
   model.add(Dense(1))
+
   model.add(Dense(<font color="blue">1</font>))
   model.add(Activation('sigmoid'))
+
   model.add(Activation(<font color="red">'sigmoid'</font>))
 
    
 
    
   model.compile(loss='binary_crossentropy',
+
   model.compile(loss=<font color="red">'binary_crossentropy'</font>,
                 optimizer='adam',
+
                 optimizer=<font color="red">'adam'</font>,
                 metrics=['accuracy'])
+
                 metrics=[<font color="red">'accuracy'</font>])
 
   model.fit(x_train, y_train,
 
   model.fit(x_train, y_train,
 
             batch_size=batch_size,
 
             batch_size=batch_size,
 
             epochs=epochs,
 
             epochs=epochs,
 
             validation_data=(x_test, y_test))
 
             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.
 +
* [https://github.com/HIPS/autograd Autograd] - Библиотека автодифференциирования функций на numpy. ПОзволяет делать простые нейросети и оптимизацию научных расчётов. Для тяжёлого лучше использовать GPU-библиотеки.
 +
* [https://github.com/google/jax JAX] - улучшенный autograd.
 +
* [https://github.com/ofnote/tsalib Tensor shape annotation lib] - позволяет назначить измерениям тензора человекочитаемые метки
 +
 +
===Библиотеки для глубокого обучения===
 +
* Tenzorflow<ref>https://www.tensorflow.org</ref> - открытая программная библиотека для машинного обучения, разработанная компанией Google для решения задач построения и тренировки нейронной сети с целью автоматического нахождения и классификации образов, достигая качества человеческого восприятия. Широко применяется в бизнес-приложениях.
 +
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU (OpenCL) и глубокие нейронные сети на базе системы 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, предоставляющий реализации архитектур различных нейронных сетей.
 +
* [https://github.com/plaidml/plaidml plaidml] - ещё одна библиотека на OpenCL, умеющая компилировать граф в оптимизированные кастомные ядра OpenCL.
 +
 +
===Библиотеки для обработки естественного языка===
 +
* 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]]
+
*[[:Примеры кода на R|Примеры кода на R]]<sup>[на 28.01.19 не создан]</sup>
 
*[[:Примеры кода на Java|Примеры кода на Java]]
 
*[[:Примеры кода на Java|Примеры кода на Java]]
 +
 
==Примечания==
 
==Примечания==
 
<references/>
 
<references/>
  
[[Категория: Машинное обучение]]
+
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]
[[Категория: Нейронные сети]]
 

Текущая версия на 19:15, 4 сентября 2022

Scikit-learn

Описание

Scikit-learn[1] — библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение Кросс-валидация[на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: линейной регрессии[на 28.01.19 не создан] и её модификаций Лассо, гребневой регрессии, опорных векторов[на 28.01.19 не создан], решающих деревьев и лесов и др. Есть и реализации основных методов кластеризации. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности методом главных компонент[на 28.01.19 не создан]. Частью пакета является библиотека imblearn[2], позволяющая работать с разбалансированными выборками и генерировать новые значения.

Примеры кода

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

 # Add required imports
 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()
 # Use only one feature
 diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:

 # Split the data into training/testing sets
 x_train = diabetes_X[:-20]
 x_test = diabetes_X[-20:]
 
 # Split the targets into training/testing sets
 y_train = diabetes.target[:-20]
 y_test = diabetes.target[-20:]

Построение и обучение модели:

 lr = LinearRegression()
 lr.fit(x_train, y_train)
 predictions = lr.predict(x_test)

Оценка алгоритма:

 # The mean squared error
 print("Mean squared error: %.2f"
       % mean_squared_error(y_test, predictions))
 # Explained variance score: 1 is perfect prediction
 print('Variance score: %.2f' % r2_score(y_test, predictions))
 > Mean squared error: 2548.07
   Variance score: 0.47

Построение графика прямой, получившейся в результате работы линейной регрессии:

 plt.scatter(x_test, y_test,  color='black')
 plt.plot(x_test, predictions, color='blue', linewidth=3)
 plt.xticks(())
 plt.yticks(())
 plt.show()
Diabetes-sklearn.png

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

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

Загрузка датасета:

 from sklearn.datasets import load_digits
 digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:

 import numpy as np
 import matplotlib.pyplot as plt
 
 plt.figure(figsize=(20,4))
 for index, (image, label) in enumerate(zip(digits.data[0:3], digits.target[0:3])):
   plt.subplot(1, 3, index + 1)
   plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
   plt.title('Training: %i\n' % label, fontsize = 20)
Digits-sklearn.png

Разбиение датасета на тренировочный и тестовый:

 from sklearn.model_selection import train_test_split
 x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:

 from sklearn.linear_model import LogisticRegression
 lr = LogisticRegression()
 lr.fit(x_train, y_train)
 predictions = lr.predict(x_test)

Оценка алгоритма:

 score = lr.score(x_test, y_test)
 print("Score: %.3f" % score)
 > Score: 0.953

Перцептрон

Загрузка датасета:

 from sklearn import datasets
 iris = datasets.load_iris()
 X = iris.data
 y = iris.target

Разбиение датасета на тренировочный и тестовый:

 from sklearn.model_selection import train_test_split
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:

 from sklearn.preprocessing import StandardScaler
 scaler = StandardScaler()
 scaler.fit(X_train)
 X_train = scaler.transform(X_train)
 X_test = scaler.transform(X_test)

Построение и обучение модели:

 from sklearn.neural_network import MLPClassifier
 mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
 mlp.fit(X_train, y_train.values.ravel())
 predictions = mlp.predict(X_test)

Оценка алгоритма:

 from sklearn.metrics import classification_report, confusion_matrix
 print(confusion_matrix(y_test,predictions))
 print(classification_report(y_test,predictions))
 > [[ 7  0  0]
    [ 0  8  1]
    [ 0  2 12]]
                 precision    recall  f1-score   support
 
              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

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

Дерево решений и случайный лес

Обработка естественного языка

Загрузка датасета:

 from sklearn import fetch_20newsgroups
 twenty_train = fetch_20newsgroups(subset='train', shuffle=True, random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:

 print("\n".join(twenty_train.data[0].split("\n")[:3]))
 print(twenty_train.target_names[twenty_train.target[0]])
 > From: lerxst@wam.umd.edu (where's my thing)
   Subject: WHAT car is this!?
   Nntp-Posting-Host: rac3.wam.umd.edu
 
   rec.autos

Построение и обучение двух моделей. Первая на основе Байесовской классификации[на 28.01.19 не создан], а вторая использует метод опорных векторов:

 from sklearn.pipeline import Pipeline
 from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
 
 from sklearn.naive_bayes import MultinomialNB
 text_clf1 = Pipeline([
   ('vect', CountVectorizer()),
   ('tfidf', TfidfTransformer()),
   ('clf', MultinomialNB()),
 ])
 
 from sklearn.linear_model import SGDClassifier
 text_clf2 = Pipeline([
   ('vect', CountVectorizer()),
   ('tfidf', TfidfTransformer()),
   ('clf', SGDClassifier(loss='hinge', penalty='l2',
                         alpha=1e-3, random_state=42,
                         max_iter=5, 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='test', shuffle=True, random_state=42)
 docs_test = twenty_test.data
 predicted1 = text_clf1.predict(docs_test)
 predicted2 = text_clf2.predict(docs_test)
 print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
 print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))
 > Score for naive Bayes: 0.774
   Score for SVM: 0.824

Кросс-валилация и подбор параметров

Основная статья: Кросс-валидация

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:

 from sklearn.model_selection import GridSearchCV
 parameters = {
     'vect__ngram_range': [(1, 1), (1, 2)],
     'tfidf__use_idf': (True, False),
     'clf__alpha': (1e-2, 1e-3),
 }
 
 gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid=False, n_jobs=-1)
 gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)
 
 print("Best score: %.3f" % gs_clf.best_score_)
 
 for param_name in sorted(parameters.keys()):
   print("%s: %r" % (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)

Загрузка датасета:

 from sklearn import datasets
 iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:

 from sklearn.model_selection import train_test_split
 x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:

 clf = svm.SVC(kernel='linear', C=1.0)
 clf.fit(x_train, y_train)
 predictions = clf.predict(x_test)

Оценка алгоритма:

 from sklearn.metrics import classification_report, confusion_matrix
 print(confusion_matrix(y_test,predictions))
 print(classification_report(y_test,predictions))
 > [[13  0  0]
    [ 0 15  1]
    [ 0  0  9]]
                 precision    recall  f1-score   support
 
              0       1.00      1.00      1.00        13
              1       1.00      0.94      0.97        16
              2       0.90      1.00      0.95         9
 
      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-алгоритм

 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib.colors import LogNorm
 from sklearn import mixture
 
 n_samples = 300
 
 # generate random sample, two components
 np.random.seed(0)
 
 # generate spherical data centered on (20, 20)
 shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])
 
 # generate zero centered stretched Gaussian data
 C = np.array([[0., -0.7], [3.5, .7]])
 stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)
 
 # concatenate the two datasets into the final training set
 X_train = np.vstack([shifted_gaussian, stretched_gaussian])
 
 # fit a Gaussian Mixture Model with two components
 clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
 clf.fit(X_train)
 
 # display predicted scores by the model as a contour plot
 x = np.linspace(-20., 30.)
 y = np.linspace(-20., 40.)
 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=1.0, vmax=1000.0),
                  levels=np.logspace(0, 3, 10))
 CB = plt.colorbar(CS, shrink=0.8, extend='both')
 plt.scatter(X_train[:, 0], X_train[:, 1], .8)
 
 plt.title('Negative log-likelihood predicted by a GMM')
 plt.axis('tight')
 plt.show()
Em.png

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

Tensorflow

Описание

Tensorflow[3] — библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.

Примеры кода

Сверточная нейронная сеть

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:

 from __future__ import division, print_function, absolute_import
 import tensorflow as tf
 
 # Import MNIST data
 from tensorflow.examples.tutorials.mnist import input_data
 mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
 
 # Training Parameters
 learning_rate = 0.001
 num_steps = 200
 batch_size = 128
 display_step = 10
 
 # Network Parameters
 num_input = 784 # MNIST data input (img shape: 28*28)
 num_classes = 10 # MNIST total classes (0-9 digits)
 dropout = 0.75 # Dropout, probability to keep units
 
 # tf Graph input
 X = tf.placeholder(tf.float32, [None, num_input])
 Y = tf.placeholder(tf.float32, [None, num_classes])
 keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)
 
 # Create some wrappers for simplicity
 def conv2d(x, W, b, strides=1):
   # Conv2D wrapper, with bias and relu activation
   x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
   x = tf.nn.bias_add(x, b)
   return tf.nn.relu(x)
 
 def maxpool2d(x, k=2):
   # MaxPool2D wrapper
   return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
                         padding='SAME')
 
 # Create model
 def conv_net(x, weights, biases, dropout):
   # 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]
   x = tf.reshape(x, shape=[-1, 28, 28, 1])
   # Convolution Layer
   conv1 = conv2d(x, weights['wc1'], biases['bc1'])
   # Max Pooling (down-sampling)
   conv1 = maxpool2d(conv1, k=2)
   # Convolution Layer
   conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
   # Max Pooling (down-sampling)
   conv2 = maxpool2d(conv2, k=2)
   # Fully connected layer
   # Reshape conv2 output to fit fully connected layer input
   fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
   fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
   fc1 = tf.nn.relu(fc1)
   # Apply Dropout
   fc1 = tf.nn.dropout(fc1, dropout)
   # Output, class prediction
   out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
   return out
 
 # Store layers weight & bias
 weights = {
   # 5x5 conv, 1 input, 32 outputs
   'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
   # 5x5 conv, 32 inputs, 64 outputs
   'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
   # fully connected, 7*7*64 inputs, 1024 outputs
   'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
   # 1024 inputs, 10 outputs (class prediction)
   'out': tf.Variable(tf.random_normal([1024, num_classes]))
 }
 
 biases = {
   'bc1': tf.Variable(tf.random_normal([32])),
   'bc2': tf.Variable(tf.random_normal([64])),
   'bd1': tf.Variable(tf.random_normal([1024])),
   'out': tf.Variable(tf.random_normal([num_classes]))
 }
 
 # Construct model
 logits = conv_net(X, weights, biases, keep_prob)
 prediction = tf.nn.softmax(logits)
 
 # Define loss and optimizer
 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)
 
 # Evaluate model
 correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
 accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
 
 # Initialize the variables (i.e. assign their default value)
 init = tf.global_variables_initializer()
 
 # Start training
 with tf.Session() as sess:
   # Run the initializer
   sess.run(init)
   for step in range(1, num_steps+1):
     batch_x, batch_y = mnist.train.next_batch(batch_size)
     # Run optimization op (backprop)
     sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
     if step % display_step == 0 or step == 1:
       # Calculate batch loss and accuracy
       loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
                                                            Y: batch_y,
                                                            keep_prob: 1.0})
       print("Step " + str(step) + ", Minibatch Loss= " + \
             "{:.4f}".format(loss) + ", Training Accuracy= " + \
             "{:.3f}".format(acc))
   print("Optimization Finished!")
   # Calculate accuracy for 256 MNIST test images
   print("Testing Accuracy:", \
     sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
                                   Y: mnist.test.labels[:256],
                                   keep_prob: 1.0}))
 > 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[4] — библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.

Примеры кода

Сверточная нейронная сеть

Реализация сверточной нейронной сети для классификации текста:

 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
 
 # set parameters:
 max_features = 5000
 maxlen = 400
 batch_size = 32
 embedding_dims = 50
 filters = 250
 kernel_size = 3
 hidden_dims = 250
 epochs = 2
 
 (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
 print(len(x_train), 'train sequences')
 print(len(x_test), 'test sequences')
 > 25000 train sequences
   25000 test sequences
 print('Pad sequences (samples x time)')
 x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
 x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
 print('x_train shape:', x_train.shape)
 print('x_test shape:', 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(0.2))  
 model.add(Conv1D(filters,
                  kernel_size,
                  padding='valid',
                  activation='relu',
                  strides=1))
 model.add(GlobalMaxPooling1D())
 model.add(Dense(hidden_dims))
 model.add(Dropout(0.2))
 model.add(Activation('relu'))
 model.add(Dense(1))
 model.add(Activation('sigmoid'))
 
 model.compile(loss='binary_crossentropy',
               optimizer='adam',
               metrics=['accuracy'])
 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[5] — библиотека, добавляющая поддержку больших многомерных массивов и матриц вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB[6];
  • SciPy[7] — открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке;
  • Pandas[8] — библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib;
  • Matplotlib[9] — библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython[10] предоставляет возможности, подобные MATLAB.
  • Autograd - Библиотека автодифференциирования функций на numpy. ПОзволяет делать простые нейросети и оптимизацию научных расчётов. Для тяжёлого лучше использовать GPU-библиотеки.
  • JAX - улучшенный autograd.
  • Tensor shape annotation lib - позволяет назначить измерениям тензора человекочитаемые метки

Библиотеки для глубокого обучения

  • Tenzorflow[11] - открытая программная библиотека для машинного обучения, разработанная компанией Google для решения задач построения и тренировки нейронной сети с целью автоматического нахождения и классификации образов, достигая качества человеческого восприятия. Широко применяется в бизнес-приложениях.
  • PyTorch[12] — библиотека для глубокого обучения, созданная на базе Torch[13] и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки — тензорные вычисления с развитой поддержкой ускорения на GPU (OpenCL) и глубокие нейронные сети на базе системы autodiff;
  • Theano[14] — расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач;
  • Caffe[15] — фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA;
  • Microsoft Cognitive Toolkit (CNTK)[16] — фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.
  • plaidml - ещё одна библиотека на OpenCL, умеющая компилировать граф в оптимизированные кастомные ядра OpenCL.

Библиотеки для обработки естественного языка

  • NLTK[17] — пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python;
  • Gensim[18] — инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

Библиотеки для градиентного бустинга

  • Xgboost[на 28.01.19 не создан][19] — библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм;
  • LightGBM[20] — фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net;
  • CatBoost[21] — библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

См. также

Примечания