Pushing the docs to dev/ for branch: master, commit 7f0e433183dcfc0d6fb5bc5e18bd2bec39e48701

Author: sklearn-ci

dev/_downloads/auto_examples_jupyter.zip

@@ -26,7 +26,7 @@
       },
       "outputs": [],
       "source": [
-        "print(__doc__)\n\n# Author: Gael Varoquaux <[email protected]>, Brian Cheung\n# License: BSD 3 clause\n\nimport time\n\nimport numpy as np\nimport scipy as sp\nimport matplotlib.pyplot as plt\n\nfrom sklearn.feature_extraction import image\nfrom sklearn.cluster import spectral_clustering\nfrom sklearn.externals._pilutil import imresize\n\n\n# load the raccoon face as a numpy array\ntry:  # SciPy >= 0.16 have face in misc\n    from scipy.misc import face\n    face = face(gray=True)\nexcept ImportError:\n    face = sp.face(gray=True)\n\n# Resize it to 10% of the original size to speed up the processing\nface = imresize(face, 0.10) / 255.\n\n# Convert the image into a graph with the value of the gradient on the\n# edges.\ngraph = image.img_to_graph(face)\n\n# Take a decreasing function of the gradient: an exponential\n# The smaller beta is, the more independent the segmentation is of the\n# actual image. For beta=1, the segmentation is close to a voronoi\nbeta = 5\neps = 1e-6\ngraph.data = np.exp(-beta * graph.data / graph.data.std()) + eps\n\n# Apply spectral clustering (this step goes much faster if you have pyamg\n# installed)\nN_REGIONS = 25"
+        "print(__doc__)\n\n# Author: Gael Varoquaux <[email protected]>, Brian Cheung\n# License: BSD 3 clause\n\nimport time\n\nimport numpy as np\nimport scipy as sp\nfrom scipy.ndimage.filters import gaussian_filter\nimport matplotlib.pyplot as plt\nfrom skimage import img_as_float\nfrom skimage.transform import rescale\n\nfrom sklearn.feature_extraction import image\nfrom sklearn.cluster import spectral_clustering\n\n\n# load the raccoon face as a numpy array\ntry:  # SciPy >= 0.16 have face in misc\n    from scipy.misc import face\n    orig_face = img_as_float(face(gray=True))\nexcept ImportError:\n    orig_face = img_as_float(sp.face(gray=True))\n\n# Resize it to 10% of the original size to speed up the processing\n# Applying a Gaussian filter for smoothing prior to down-scaling\n# reduces aliasing artifacts.\nsmoothened_face = gaussian_filter(orig_face, sigma=4.5)\nrescaled_face = rescale(smoothened_face, 0.1, mode=\"reflect\")\n\n# Convert the image into a graph with the value of the gradient on the\n# edges.\ngraph = image.img_to_graph(rescaled_face)\n\n# Take a decreasing function of the gradient: an exponential\n# The smaller beta is, the more independent the segmentation is of the\n# actual image. For beta=1, the segmentation is close to a voronoi\nbeta = 5\neps = 1e-6\ngraph.data = np.exp(-beta * graph.data / graph.data.std()) + eps\n\n# Apply spectral clustering (this step goes much faster if you have pyamg\n# installed)\nN_REGIONS = 25"
       ]
     },
     {
@@ -44,7 +44,7 @@
       },
       "outputs": [],
       "source": [
-        "for assign_labels in ('kmeans', 'discretize'):\n    t0 = time.time()\n    labels = spectral_clustering(graph, n_clusters=N_REGIONS,\n                                 assign_labels=assign_labels, random_state=42)\n    t1 = time.time()\n    labels = labels.reshape(face.shape)\n\n    plt.figure(figsize=(5, 5))\n    plt.imshow(face, cmap=plt.cm.gray)\n    for l in range(N_REGIONS):\n        plt.contour(labels == l,\n                    colors=[plt.cm.spectral(l / float(N_REGIONS))])\n    plt.xticks(())\n    plt.yticks(())\n    title = 'Spectral clustering: %s, %.2fs' % (assign_labels, (t1 - t0))\n    print(title)\n    plt.title(title)\nplt.show()"
+        "for assign_labels in ('kmeans', 'discretize'):\n    t0 = time.time()\n    labels = spectral_clustering(graph, n_clusters=N_REGIONS,\n                                 assign_labels=assign_labels, random_state=42)\n    t1 = time.time()\n    labels = labels.reshape(rescaled_face.shape)\n\n    plt.figure(figsize=(5, 5))\n    plt.imshow(rescaled_face, cmap=plt.cm.gray)\n    for l in range(N_REGIONS):\n        plt.contour(labels == l,\n                    colors=[plt.cm.spectral(l / float(N_REGIONS))])\n    plt.xticks(())\n    plt.yticks(())\n    title = 'Spectral clustering: %s, %.2fs' % (assign_labels, (t1 - t0))\n    print(title)\n    plt.title(title)\nplt.show()"
       ]
     }
   ],

dev/_downloads/auto_examples_python.zip

@@ -26,26 +26,31 @@
 
 import numpy as np
 import scipy as sp
+from scipy.ndimage.filters import gaussian_filter
 import matplotlib.pyplot as plt
+from skimage import img_as_float
+from skimage.transform import rescale
 
 from sklearn.feature_extraction import image
 from sklearn.cluster import spectral_clustering
-from sklearn.externals._pilutil import imresize
 
 
 # load the raccoon face as a numpy array
 try:  # SciPy >= 0.16 have face in misc
     from scipy.misc import face
-    face = face(gray=True)
+    orig_face = img_as_float(face(gray=True))
 except ImportError:
-    face = sp.face(gray=True)
+    orig_face = img_as_float(sp.face(gray=True))
 
 # Resize it to 10% of the original size to speed up the processing
-face = imresize(face, 0.10) / 255.
+# Applying a Gaussian filter for smoothing prior to down-scaling
+# reduces aliasing artifacts.
+smoothened_face = gaussian_filter(orig_face, sigma=4.5)
+rescaled_face = rescale(smoothened_face, 0.1, mode="reflect")
 
 # Convert the image into a graph with the value of the gradient on the
 # edges.
-graph = image.img_to_graph(face)
+graph = image.img_to_graph(rescaled_face)
 
 # Take a decreasing function of the gradient: an exponential
 # The smaller beta is, the more independent the segmentation is of the
@@ -66,10 +71,10 @@
     labels = spectral_clustering(graph, n_clusters=N_REGIONS,
                                  assign_labels=assign_labels, random_state=42)
     t1 = time.time()
-    labels = labels.reshape(face.shape)
+    labels = labels.reshape(rescaled_face.shape)
 
     plt.figure(figsize=(5, 5))
-    plt.imshow(face, cmap=plt.cm.gray)
+    plt.imshow(rescaled_face, cmap=plt.cm.gray)
     for l in range(N_REGIONS):
         plt.contour(labels == l,
                     colors=[plt.cm.spectral(l / float(N_REGIONS))])

dev/_downloads/plot_face_segmentation.ipynb

@@ -26,7 +26,7 @@
       },
       "outputs": [],
       "source": [
-        "# Author : Vincent Michel, 2010\n#          Alexandre Gramfort, 2011\n# License: BSD 3 clause\n\nprint(__doc__)\n\nimport time as time\n\nimport numpy as np\nimport scipy as sp\n\nimport matplotlib.pyplot as plt\n\nfrom sklearn.feature_extraction.image import grid_to_graph\nfrom sklearn.cluster import AgglomerativeClustering\nfrom sklearn.externals._pilutil import imresize\n\n\n# #############################################################################\n# Generate data\ntry:  # SciPy >= 0.16 have face in misc\n    from scipy.misc import face\n    face = face(gray=True)\nexcept ImportError:\n    face = sp.face(gray=True)\n\n# Resize it to 10% of the original size to speed up the processing\nface = imresize(face, 0.10) / 255.\n\nX = np.reshape(face, (-1, 1))\n\n# #############################################################################\n# Define the structure A of the data. Pixels connected to their neighbors.\nconnectivity = grid_to_graph(*face.shape)\n\n# #############################################################################\n# Compute clustering\nprint(\"Compute structured hierarchical clustering...\")\nst = time.time()\nn_clusters = 15  # number of regions\nward = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward',\n                               connectivity=connectivity)\nward.fit(X)\nlabel = np.reshape(ward.labels_, face.shape)\nprint(\"Elapsed time: \", time.time() - st)\nprint(\"Number of pixels: \", label.size)\nprint(\"Number of clusters: \", np.unique(label).size)\n\n# #############################################################################\n# Plot the results on an image\nplt.figure(figsize=(5, 5))\nplt.imshow(face, cmap=plt.cm.gray)\nfor l in range(n_clusters):\n    plt.contour(label == l,\n                colors=[plt.cm.spectral(l / float(n_clusters)), ])\nplt.xticks(())\nplt.yticks(())\nplt.show()"
+        "# Author : Vincent Michel, 2010\n#          Alexandre Gramfort, 2011\n# License: BSD 3 clause\n\nprint(__doc__)\n\nimport time as time\n\nimport numpy as np\nimport scipy as sp\nfrom scipy.ndimage.filters import gaussian_filter\n\nimport matplotlib.pyplot as plt\n\nfrom skimage import img_as_float\nfrom skimage.transform import rescale\n\nfrom sklearn.feature_extraction.image import grid_to_graph\nfrom sklearn.cluster import AgglomerativeClustering\n\n\n# #############################################################################\n# Generate data\ntry:  # SciPy >= 0.16 have face in misc\n    from scipy.misc import face\n    orig_face = img_as_float(face(gray=True))\nexcept ImportError:\n    orig_face = img_as_float(sp.face(gray=True))\n\n# Resize it to 10% of the original size to speed up the processing\n# Applying a Gaussian filter for smoothing prior to down-scaling\n# reduces aliasing artifacts.\nsmoothened_face = gaussian_filter(orig_face, sigma=4.5)\nrescaled_face = rescale(smoothened_face, 0.1, mode=\"reflect\")\n\nX = np.reshape(rescaled_face, (-1, 1))\n\n# #############################################################################\n# Define the structure A of the data. Pixels connected to their neighbors.\nconnectivity = grid_to_graph(*rescaled_face.shape)\n\n# #############################################################################\n# Compute clustering\nprint(\"Compute structured hierarchical clustering...\")\nst = time.time()\nn_clusters = 15  # number of regions\nward = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward',\n                               connectivity=connectivity)\nward.fit(X)\nlabel = np.reshape(ward.labels_, rescaled_face.shape)\nprint(\"Elapsed time: \", time.time() - st)\nprint(\"Number of pixels: \", label.size)\nprint(\"Number of clusters: \", np.unique(label).size)\n\n# #############################################################################\n# Plot the results on an image\nplt.figure(figsize=(5, 5))\nplt.imshow(rescaled_face, cmap=plt.cm.gray)\nfor l in range(n_clusters):\n    plt.contour(label == l,\n                colors=[plt.cm.spectral(l / float(n_clusters)), ])\nplt.xticks(())\nplt.yticks(())\nplt.show()"
       ]
     }
   ],

dev/_downloads/plot_face_segmentation.py

@@ -18,30 +18,36 @@
 
 import numpy as np
 import scipy as sp
+from scipy.ndimage.filters import gaussian_filter
 
 import matplotlib.pyplot as plt
 
+from skimage import img_as_float
+from skimage.transform import rescale
+
 from sklearn.feature_extraction.image import grid_to_graph
 from sklearn.cluster import AgglomerativeClustering
-from sklearn.externals._pilutil import imresize
 
 
 # #############################################################################
 # Generate data
 try:  # SciPy >= 0.16 have face in misc
     from scipy.misc import face
-    face = face(gray=True)
+    orig_face = img_as_float(face(gray=True))
 except ImportError:
-    face = sp.face(gray=True)
+    orig_face = img_as_float(sp.face(gray=True))
 
 # Resize it to 10% of the original size to speed up the processing
-face = imresize(face, 0.10) / 255.
+# Applying a Gaussian filter for smoothing prior to down-scaling
+# reduces aliasing artifacts.
+smoothened_face = gaussian_filter(orig_face, sigma=4.5)
+rescaled_face = rescale(smoothened_face, 0.1, mode="reflect")
 
-X = np.reshape(face, (-1, 1))
+X = np.reshape(rescaled_face, (-1, 1))
 
 # #############################################################################
 # Define the structure A of the data. Pixels connected to their neighbors.
-connectivity = grid_to_graph(*face.shape)
+connectivity = grid_to_graph(*rescaled_face.shape)
 
 # #############################################################################
 # Compute clustering
@@ -51,15 +57,15 @@
 ward = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward',
                                connectivity=connectivity)
 ward.fit(X)
-label = np.reshape(ward.labels_, face.shape)
+label = np.reshape(ward.labels_, rescaled_face.shape)
 print("Elapsed time: ", time.time() - st)
 print("Number of pixels: ", label.size)
 print("Number of clusters: ", np.unique(label).size)
 
 # #############################################################################
 # Plot the results on an image
 plt.figure(figsize=(5, 5))
-plt.imshow(face, cmap=plt.cm.gray)
+plt.imshow(rescaled_face, cmap=plt.cm.gray)
 for l in range(n_clusters):
     plt.contour(label == l,
                 colors=[plt.cm.spectral(l / float(n_clusters)), ])