Update gh-pages

Author: William de Vazelhes

.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 89e7bf0528b77a77d89d8167f4184500
+config: 7a311e9c0e4adf6a4015559eaf8b21ea
 tags: 645f666f9bcd5a90fca523b33c5a78b7

_downloads/47d7e96fc5ed57a08669b70c0daf7f4f/plot_metric_learning_examples.py renamed to _downloads/1701602fecf66f059913dd6559226da0/plot_metric_learning_examples.py

@@ -88,7 +88,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 # distances between points for the task at hand. Especially in higher
 # dimensions when Euclidean distances are a poor way to measure distance, this
 # becomes very useful.
-# 
+#
 # Basically, we learn this distance:
 # :math:`D(x, x') = \sqrt{(x-x')^\top M(x-x')}`. And we learn the parameters
 # :math:`M` of this distance to satisfy certain constraints on the distance
@@ -113,12 +113,12 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Large Margin Nearest Neighbour
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# 
+#
 # LMNN is a metric learning algorithm primarily designed for k-nearest
 # neighbor classification. The algorithm is based on semidefinite
 # programming, a sub-class of convex programming (as most Metric Learning
 # algorithms are).
-# 
+#
 # The main intuition behind LMNN is to learn a pseudometric under which
 # all data instances in the training set are surrounded by at least k
 # instances that share the same class label. If this is achieved, the
@@ -136,7 +136,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Fit and then transform!
 # -----------------------
-# 
+#
 
 # setting up LMNN
 lmnn = metric_learn.LMNN(k=5, learn_rate=1e-6)
@@ -162,7 +162,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 
 ######################################################################
 # Pretty neat, huh?
-# 
+#
 # The rest of this notebook will briefly explain the other Metric Learning
 # algorithms before plotting them. Also, while we have first run ``fit``
 # and then ``transform`` to see our data transformed, we can also use
@@ -172,7 +172,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Information Theoretic Metric Learning
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# 
+#
 # ITML uses a regularizer that automatically enforces a Semi-Definite
 # Positive Matrix condition - the LogDet divergence. It uses soft
 # must-link or cannot like constraints, and a simple algorithm based on
@@ -231,7 +231,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Least Squares Metric Learning
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# 
+#
 # LSML is a simple, yet effective, algorithm that learns a Mahalanobis
 # metric from a given set of relative comparisons. This is done by
 # formulating and minimizing a convex loss function that corresponds to
@@ -277,7 +277,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Local Fisher Discriminant Analysis
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# 
+#
 # LFDA is a linear supervised dimensionality reduction method. It is
 # particularly useful when dealing with multimodality, where one ore more
 # classes consist of separate clusters in input space. The core
@@ -298,7 +298,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 ######################################################################
 # Relative Components Analysis
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# 
+#
 # RCA is another one of the older algorithms. It learns a full rank
 # Mahalanobis distance metric based on a weighted sum of in-class
 # covariance matrices. It applies a global linear transformation to assign
@@ -402,7 +402,7 @@ def plot_tsne(X, y, colormap=plt.cm.Paired):
 def create_constraints(labels):
     import itertools
     import random
-    
+
     # aggregate indices of same class
     zeros = np.where(y == 0)[0]
     ones = np.where(y == 1)[0]
@@ -413,7 +413,7 @@ def create_constraints(labels):
     twos_ = list(itertools.combinations(twos, 2))
     # put them together!
     sim = np.array(zeros_ + ones_ + twos_)
-    
+
     # similarily, put together indices in different classes
     dis = []
     for zero in zeros:
@@ -424,21 +424,25 @@ def create_constraints(labels):
     for one in ones:
         for two in twos:
             dis.append((one, two))
-            
+
     # pick up just enough dissimilar examples as we have similar examples
     dis = np.array(random.sample(dis, len(sim)))
-    
-    # return an array of pairs of indices of shape=(2*len(sim), 2), and the corresponding labels, array of shape=(2*len(sim))
-    # Each pair of similar points have a label of +1 and each pair of dissimilar points have a label of -1
-    return (np.vstack([np.column_stack([sim[:, 0], sim[:, 1]]), np.column_stack([dis[:, 0], dis[:, 1]])]),
+
+    # return an array of pairs of indices of shape=(2*len(sim), 2), and the
+    # corresponding labels, array of shape=(2*len(sim))
+    # Each pair of similar points have a label of +1 and each pair of
+    # dissimilar points have a label of -1
+    return (np.vstack([np.column_stack([sim[:, 0], sim[:, 1]]),
+                       np.column_stack([dis[:, 0], dis[:, 1]])]),
             np.concatenate([np.ones(len(sim)), -np.ones(len(sim))]))
 
+
 pairs, pairs_labels = create_constraints(y)
 
 
 ######################################################################
 # Now that we've created our constraints, let's see what it looks like!
-# 
+#
 
 print(pairs)
 print(pairs_labels)

_downloads/2bcf5e32b5d52d84565bc06c5ad91c98/plot_sandwich.ipynb

@@ -0,0 +1,54 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\nSandwich demo\n=============\n\nSandwich demo based on code from http://nbviewer.ipython.org/6576096\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\nfrom matplotlib import pyplot as plt\nfrom sklearn.metrics import pairwise_distances\nfrom sklearn.neighbors import NearestNeighbors\n\nfrom metric_learn import (LMNN, ITML_Supervised, LSML_Supervised,\n                          SDML_Supervised)\n\n\ndef sandwich_demo():\n  x, y = sandwich_data()\n  knn = nearest_neighbors(x, k=2)\n  ax = plt.subplot(3, 1, 1)  # take the whole top row\n  plot_sandwich_data(x, y, ax)\n  plot_neighborhood_graph(x, knn, y, ax)\n  ax.set_title('input space')\n  ax.set_aspect('equal')\n  ax.set_xticks([])\n  ax.set_yticks([])\n\n  mls = [\n      LMNN(),\n      ITML_Supervised(num_constraints=200),\n      SDML_Supervised(num_constraints=200, balance_param=0.001),\n      LSML_Supervised(num_constraints=200),\n  ]\n\n  for ax_num, ml in enumerate(mls, start=3):\n    ml.fit(x, y)\n    tx = ml.transform(x)\n    ml_knn = nearest_neighbors(tx, k=2)\n    ax = plt.subplot(3, 2, ax_num)\n    plot_sandwich_data(tx, y, axis=ax)\n    plot_neighborhood_graph(tx, ml_knn, y, axis=ax)\n    ax.set_title(ml.__class__.__name__)\n    ax.set_xticks([])\n    ax.set_yticks([])\n  plt.show()\n\n\n# TODO: use this somewhere\ndef visualize_class_separation(X, labels):\n  _, (ax1, ax2) = plt.subplots(ncols=2)\n  label_order = np.argsort(labels)\n  ax1.imshow(pairwise_distances(X[label_order]), interpolation='nearest')\n  ax2.imshow(pairwise_distances(labels[label_order, None]),\n             interpolation='nearest')\n\n\ndef nearest_neighbors(X, k=5):\n  knn = NearestNeighbors(n_neighbors=k)\n  knn.fit(X)\n  return knn.kneighbors(X, return_distance=False)\n\n\ndef sandwich_data():\n  # number of distinct classes\n  num_classes = 6\n  # number of points per class\n  num_points = 9\n  # distance between layers, the points of each class are in a layer\n  dist = 0.7\n\n  data = np.zeros((num_classes, num_points, 2), dtype=float)\n  labels = np.zeros((num_classes, num_points), dtype=int)\n\n  x_centers = np.arange(num_points, dtype=float) - num_points / 2\n  y_centers = dist * (np.arange(num_classes, dtype=float) - num_classes / 2)\n  for i, yc in enumerate(y_centers):\n    for k, xc in enumerate(x_centers):\n      data[i, k, 0] = np.random.normal(xc, 0.1)\n      data[i, k, 1] = np.random.normal(yc, 0.1)\n    labels[i, :] = i\n  return data.reshape((-1, 2)), labels.ravel()\n\n\ndef plot_sandwich_data(x, y, axis=plt, colors='rbgmky'):\n  for idx, val in enumerate(np.unique(y)):\n    xi = x[y == val]\n    axis.scatter(*xi.T, s=50, facecolors='none', edgecolors=colors[idx])\n\n\ndef plot_neighborhood_graph(x, nn, y, axis=plt, colors='rbgmky'):\n  for i, a in enumerate(x):\n    b = x[nn[i, 1]]\n    axis.plot((a[0], b[0]), (a[1], b[1]), colors[y[i]])\n\n\nif __name__ == '__main__':\n  sandwich_demo()"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.7.1"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

_downloads/c3c89065d16de63f152d556f31fd7ee6/plot_metric_learning_examples.ipynb renamed to _downloads/434a24c66bbfd5f8398470a8c859e27b/plot_metric_learning_examples.ipynb

@@ -367,7 +367,7 @@
       },
       "outputs": [],
       "source": [
-        "def create_constraints(labels):\n    import itertools\n    import random\n    \n    # aggregate indices of same class\n    zeros = np.where(y == 0)[0]\n    ones = np.where(y == 1)[0]\n    twos = np.where(y == 2)[0]\n    # make permutations of all those points in the same class\n    zeros_ = list(itertools.combinations(zeros, 2))\n    ones_ = list(itertools.combinations(ones, 2))\n    twos_ = list(itertools.combinations(twos, 2))\n    # put them together!\n    sim = np.array(zeros_ + ones_ + twos_)\n    \n    # similarily, put together indices in different classes\n    dis = []\n    for zero in zeros:\n        for one in ones:\n            dis.append((zero, one))\n        for two in twos:\n            dis.append((zero, two))\n    for one in ones:\n        for two in twos:\n            dis.append((one, two))\n            \n    # pick up just enough dissimilar examples as we have similar examples\n    dis = np.array(random.sample(dis, len(sim)))\n    \n    # return an array of pairs of indices of shape=(2*len(sim), 2), and the corresponding labels, array of shape=(2*len(sim))\n    #\u00a0Each pair of similar points have a label of +1 and each pair of dissimilar points have a label of -1\n    return (np.vstack([np.column_stack([sim[:, 0], sim[:, 1]]), np.column_stack([dis[:, 0], dis[:, 1]])]),\n            np.concatenate([np.ones(len(sim)), -np.ones(len(sim))]))\n\npairs, pairs_labels = create_constraints(y)"
+        "def create_constraints(labels):\n    import itertools\n    import random\n\n    # aggregate indices of same class\n    zeros = np.where(y == 0)[0]\n    ones = np.where(y == 1)[0]\n    twos = np.where(y == 2)[0]\n    # make permutations of all those points in the same class\n    zeros_ = list(itertools.combinations(zeros, 2))\n    ones_ = list(itertools.combinations(ones, 2))\n    twos_ = list(itertools.combinations(twos, 2))\n    # put them together!\n    sim = np.array(zeros_ + ones_ + twos_)\n\n    # similarily, put together indices in different classes\n    dis = []\n    for zero in zeros:\n        for one in ones:\n            dis.append((zero, one))\n        for two in twos:\n            dis.append((zero, two))\n    for one in ones:\n        for two in twos:\n            dis.append((one, two))\n\n    # pick up just enough dissimilar examples as we have similar examples\n    dis = np.array(random.sample(dis, len(sim)))\n\n    # return an array of pairs of indices of shape=(2*len(sim), 2), and the\n    # corresponding labels, array of shape=(2*len(sim))\n    # Each pair of similar points have a label of +1 and each pair of\n    # dissimilar points have a label of -1\n    return (np.vstack([np.column_stack([sim[:, 0], sim[:, 1]]),\n                       np.column_stack([dis[:, 0], dis[:, 1]])]),\n            np.concatenate([np.ones(len(sim)), -np.ones(len(sim))]))\n\n\npairs, pairs_labels = create_constraints(y)"
       ]
     },
     {

_downloads/1e6862ea24bc862357b6b17e58c7e812/plot_sandwich.py renamed to _downloads/5632643bbb0183e351bf2b4dc2ab7c39/plot_sandwich.py

@@ -11,7 +11,8 @@
 from sklearn.metrics import pairwise_distances
 from sklearn.neighbors import NearestNeighbors
 
-from metric_learn import LMNN, ITML_Supervised, LSML_Supervised, SDML_Supervised
+from metric_learn import (LMNN, ITML_Supervised, LSML_Supervised,
+                          SDML_Supervised)
 
 
 def sandwich_demo():
@@ -47,10 +48,10 @@ def sandwich_demo():
 
 # TODO: use this somewhere
 def visualize_class_separation(X, labels):
-  _, (ax1,ax2) = plt.subplots(ncols=2)
+  _, (ax1, ax2) = plt.subplots(ncols=2)
   label_order = np.argsort(labels)
   ax1.imshow(pairwise_distances(X[label_order]), interpolation='nearest')
-  ax2.imshow(pairwise_distances(labels[label_order,None]),
+  ax2.imshow(pairwise_distances(labels[label_order, None]),
              interpolation='nearest')
 
 
@@ -77,19 +78,19 @@ def sandwich_data():
     for k, xc in enumerate(x_centers):
       data[i, k, 0] = np.random.normal(xc, 0.1)
       data[i, k, 1] = np.random.normal(yc, 0.1)
-    labels[i,:] = i
+    labels[i, :] = i
   return data.reshape((-1, 2)), labels.ravel()
 
 
 def plot_sandwich_data(x, y, axis=plt, colors='rbgmky'):
   for idx, val in enumerate(np.unique(y)):
-    xi = x[y==val]
+    xi = x[y == val]
     axis.scatter(*xi.T, s=50, facecolors='none', edgecolors=colors[idx])
 
 
 def plot_neighborhood_graph(x, nn, y, axis=plt, colors='rbgmky'):
   for i, a in enumerate(x):
-    b = x[nn[i,1]]
+    b = x[nn[i, 1]]
     axis.plot((a[0], b[0]), (a[1], b[1]), colors[y[i]])
 
 

_downloads/12b0e3dc28f1519743a1a05520733192/auto_examples_jupyter.zip renamed to _downloads/7bad39157ddf73bd946aceb8bc69eac4/auto_examples_jupyter.zip

@@ -178,7 +178,7 @@ <h1>All modules for which code is available</h1>
 
   <div role="contentinfo">
     <p>
-        &copy; Copyright 2015-2019, CJ Carey, Yuan Tang, William de Vazelhes, Aurélien Bellet, and Nathalie Vauquier
+        &copy; Copyright 2015-2019, CJ Carey, Yuan Tang, William de Vazelhes, Aurélien Bellet and Nathalie Vauquier
 
     </p>
   </div>