Pushing the docs for revision for branch: master, commit c761ba7661872fa029f07e5a1c6327612843af46

Author: sklearn-ci

dev/.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: ca7bd685c3cd43d3277e97e8df531e55
+config: 62d02c61361f099325d4a13d622765cb
 tags: 645f666f9bcd5a90fca523b33c5a78b7

dev/_downloads/plot_lena_compress.py renamed to dev/_downloads/plot_face_compress.py

@@ -6,9 +6,9 @@
 Vector Quantization Example
 =========================================================
 
-The classic image processing example, Lena, an 8-bit grayscale
-bit-depth, 512 x 512 sized image, is used here to illustrate
-how `k`-means is used for vector quantization.
+Face, a 1024 x 768 size image of a raccoon face,
+is used here to illustrate how `k`-means is
+used for vector quantization.
 
 """
 print(__doc__)
@@ -23,45 +23,52 @@
 import matplotlib.pyplot as plt
 
 from sklearn import cluster
+from sklearn.utils.testing import SkipTest
+from sklearn.utils.fixes import sp_version
 
-n_clusters = 5
-np.random.seed(0)
+if sp_version < (0, 12):
+    raise SkipTest("Skipping because SciPy version earlier than 0.12.0 and "
+                   "thus does not include the scipy.misc.face() image.")
 
 try:
-    lena = sp.lena()
+    face = sp.face(gray=True)
 except AttributeError:
-    # Newer versions of scipy have lena in misc
+    # Newer versions of scipy have face in misc
     from scipy import misc
-    lena = misc.lena()
-X = lena.reshape((-1, 1))  # We need an (n_sample, n_feature) array
+    face = misc.face(gray=True)
+
+n_clusters = 5
+np.random.seed(0)
+    
+X = face.reshape((-1, 1))  # We need an (n_sample, n_feature) array
 k_means = cluster.KMeans(n_clusters=n_clusters, n_init=4)
 k_means.fit(X)
 values = k_means.cluster_centers_.squeeze()
 labels = k_means.labels_
 
 # create an array from labels and values
-lena_compressed = np.choose(labels, values)
-lena_compressed.shape = lena.shape
+face_compressed = np.choose(labels, values)
+face_compressed.shape = face.shape
 
-vmin = lena.min()
-vmax = lena.max()
+vmin = face.min()
+vmax = face.max()
 
-# original lena
+# original face
 plt.figure(1, figsize=(3, 2.2))
-plt.imshow(lena, cmap=plt.cm.gray, vmin=vmin, vmax=256)
+plt.imshow(face, cmap=plt.cm.gray, vmin=vmin, vmax=256)
 
-# compressed lena
+# compressed face
 plt.figure(2, figsize=(3, 2.2))
-plt.imshow(lena_compressed, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)
+plt.imshow(face_compressed, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)
 
-# equal bins lena
+# equal bins face
 regular_values = np.linspace(0, 256, n_clusters + 1)
-regular_labels = np.searchsorted(regular_values, lena) - 1
+regular_labels = np.searchsorted(regular_values, face) - 1
 regular_values = .5 * (regular_values[1:] + regular_values[:-1])  # mean
-regular_lena = np.choose(regular_labels.ravel(), regular_values)
-regular_lena.shape = lena.shape
+regular_face = np.choose(regular_labels.ravel(), regular_values, mode="clip")
+regular_face.shape = face.shape
 plt.figure(3, figsize=(3, 2.2))
-plt.imshow(regular_lena, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)
+plt.imshow(regular_face, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)
 
 # histogram
 plt.figure(4, figsize=(3, 2.2))

dev/_downloads/plot_lena_segmentation.py renamed to dev/_downloads/plot_face_segmentation.py

@@ -1,7 +1,7 @@
 """
-=========================================
-Segmenting the picture of Lena in regions
-=========================================
+===================================================
+Segmenting the picture of a raccoon face in regions
+===================================================
 
 This example uses :ref:`spectral_clustering` on a graph created from
 voxel-to-voxel difference on an image to break this image into multiple
@@ -30,45 +30,58 @@
 
 from sklearn.feature_extraction import image
 from sklearn.cluster import spectral_clustering
+from sklearn.utils.testing import SkipTest
+from sklearn.utils.fixes import sp_version
 
-lena = sp.misc.lena()
-# Downsample the image by a factor of 4
-lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
-lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
+if sp_version < (0, 12):
+    raise SkipTest("Skipping because SciPy version earlier than 0.12.0 and "
+                   "thus does not include the scipy.misc.face() image.")
+
+
+# load the raccoon face as a numpy array
+try:
+    face = sp.face(gray=True)
+except AttributeError:
+    # Newer versions of scipy have face in misc
+    from scipy import misc
+    face = misc.face(gray=True)
+
+# Resize it to 10% of the original size to speed up the processing
+face = sp.misc.imresize(face, 0.10) / 255.
 
 # Convert the image into a graph with the value of the gradient on the
 # edges.
-graph = image.img_to_graph(lena)
+graph = image.img_to_graph(face)
 
 # Take a decreasing function of the gradient: an exponential
 # The smaller beta is, the more independent the segmentation is of the
 # actual image. For beta=1, the segmentation is close to a voronoi
 beta = 5
 eps = 1e-6
-graph.data = np.exp(-beta * graph.data / lena.std()) + eps
+graph.data = np.exp(-beta * graph.data / graph.data.std()) + eps
 
 # Apply spectral clustering (this step goes much faster if you have pyamg
 # installed)
-N_REGIONS = 11
+N_REGIONS = 25
 
-###############################################################################
+#############################################################################
 # Visualize the resulting regions
 
 for assign_labels in ('kmeans', 'discretize'):
     t0 = time.time()
     labels = spectral_clustering(graph, n_clusters=N_REGIONS,
-                                 assign_labels=assign_labels,
-                                 random_state=1)
+                                 assign_labels=assign_labels, random_state=1)
     t1 = time.time()
-    labels = labels.reshape(lena.shape)
+    labels = labels.reshape(face.shape)
 
     plt.figure(figsize=(5, 5))
-    plt.imshow(lena,   cmap=plt.cm.gray)
+    plt.imshow(face, cmap=plt.cm.gray)
     for l in range(N_REGIONS):
         plt.contour(labels == l, contours=1,
-                    colors=[plt.cm.spectral(l / float(N_REGIONS)), ])
+                    colors=[plt.cm.spectral(l / float(N_REGIONS))])
     plt.xticks(())
     plt.yticks(())
-    plt.title('Spectral clustering: %s, %.2fs' % (assign_labels, (t1 - t0)))
-
+    title = 'Spectral clustering: %s, %.2fs' % (assign_labels, (t1 - t0))
+    print(title)
+    plt.title(title)
 plt.show()

dev/_downloads/plot_lena_ward_segmentation.py renamed to dev/_downloads/plot_face_ward_segmentation.py

@@ -1,7 +1,7 @@
 """
-===============================================================
-A demo of structured Ward hierarchical clustering on Lena image
-===============================================================
+=========================================================================
+A demo of structured Ward hierarchical clustering on a raccoon face image
+=========================================================================
 
 Compute the segmentation of a 2D image with Ward hierarchical
 clustering. The clustering is spatially constrained in order
@@ -15,39 +15,57 @@
 print(__doc__)
 
 import time as time
+
 import numpy as np
 import scipy as sp
+
 import matplotlib.pyplot as plt
+
 from sklearn.feature_extraction.image import grid_to_graph
 from sklearn.cluster import AgglomerativeClustering
+from sklearn.utils.testing import SkipTest
+from sklearn.utils.fixes import sp_version
+
+if sp_version < (0, 12):
+    raise SkipTest("Skipping because SciPy version earlier than 0.12.0 and "
+                   "thus does not include the scipy.misc.face() image.")
+
 
 ###############################################################################
 # Generate data
-lena = sp.misc.lena()
-# Downsample the image by a factor of 4
-lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
-X = np.reshape(lena, (-1, 1))
+try:
+    face = sp.face(gray=True)
+except AttributeError:
+    # Newer versions of scipy have face in misc
+    from scipy import misc
+    face = misc.face(gray=True)
+
+# Resize it to 10% of the original size to speed up the processing
+face = sp.misc.imresize(face, 0.10) / 255.
+
+X = np.reshape(face, (-1, 1))
 
 ###############################################################################
 # Define the structure A of the data. Pixels connected to their neighbors.
-connectivity = grid_to_graph(*lena.shape)
+connectivity = grid_to_graph(*face.shape)
 
 ###############################################################################
 # Compute clustering
 print("Compute structured hierarchical clustering...")
 st = time.time()
 n_clusters = 15  # number of regions
-ward = AgglomerativeClustering(n_clusters=n_clusters,
-        linkage='ward', connectivity=connectivity).fit(X)
-label = np.reshape(ward.labels_, lena.shape)
+ward = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward',
+                               connectivity=connectivity)
+ward.fit(X)
+label = np.reshape(ward.labels_, 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(lena, cmap=plt.cm.gray)
+plt.imshow(face, cmap=plt.cm.gray)
 for l in range(n_clusters):
     plt.contour(label == l, contours=1,
                 colors=[plt.cm.spectral(l / float(n_clusters)), ])

dev/_downloads/plot_image_denoising.py

@@ -4,7 +4,7 @@
 =========================================
 
 An example comparing the effect of reconstructing noisy fragments
-of the Lena image using firstly online :ref:`DictionaryLearning` and
+of a raccoon face image using firstly online :ref:`DictionaryLearning` and
 various transform methods.
 
 The dictionary is fitted on the distorted left half of the image, and
@@ -37,32 +37,45 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-
-from scipy.misc import lena
+import scipy as sp
 
 from sklearn.decomposition import MiniBatchDictionaryLearning
 from sklearn.feature_extraction.image import extract_patches_2d
 from sklearn.feature_extraction.image import reconstruct_from_patches_2d
+from sklearn.utils.testing import SkipTest
+from sklearn.utils.fixes import sp_version
+
+if sp_version < (0, 12):
+    raise SkipTest("Skipping because SciPy version earlier than 0.12.0 and "
+                   "thus does not include the scipy.misc.face() image.")
 
 ###############################################################################
-# Load Lena image and extract patches
-lena = lena() / 256.0
+try:
+    from scipy import misc
+    face = misc.face(gray=True)
+except AttributeError:
+    # Old versions of scipy have face in the top level package
+    face = sp.face(gray=True)
+
+# Convert from uint8 representation with values between 0 and 255 to
+# a floating point representation with values between 0 and 1.
+face = face / 255
 
 # downsample for higher speed
-lena = lena[::2, ::2] + lena[1::2, ::2] + lena[::2, 1::2] + lena[1::2, 1::2]
-lena /= 4.0
-height, width = lena.shape
+face = face[::2, ::2] + face[1::2, ::2] + face[::2, 1::2] + face[1::2, 1::2]
+face /= 4.0
+height, width = face.shape
 
 # Distort the right half of the image
 print('Distorting image...')
-distorted = lena.copy()
-distorted[:, height // 2:] += 0.075 * np.random.randn(width, height // 2)
+distorted = face.copy()
+distorted[:, width // 2:] += 0.075 * np.random.randn(height, width // 2)
 
 # Extract all reference patches from the left half of the image
 print('Extracting reference patches...')
 t0 = time()
 patch_size = (7, 7)
-data = extract_patches_2d(distorted[:, :height // 2], patch_size)
+data = extract_patches_2d(distorted[:, :width // 2], patch_size)
 data = data.reshape(data.shape[0], -1)
 data -= np.mean(data, axis=0)
 data /= np.std(data, axis=0)
@@ -85,7 +98,7 @@
                interpolation='nearest')
     plt.xticks(())
     plt.yticks(())
-plt.suptitle('Dictionary learned from Lena patches\n' +
+plt.suptitle('Dictionary learned from face patches\n' +
              'Train time %.1fs on %d patches' % (dt, len(data)),
              fontsize=16)
 plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
@@ -99,7 +112,8 @@ def show_with_diff(image, reference, title):
     plt.figure(figsize=(5, 3.3))
     plt.subplot(1, 2, 1)
     plt.title('Image')
-    plt.imshow(image, vmin=0, vmax=1, cmap=plt.cm.gray, interpolation='nearest')
+    plt.imshow(image, vmin=0, vmax=1, cmap=plt.cm.gray,
+               interpolation='nearest')
     plt.xticks(())
     plt.yticks(())
     plt.subplot(1, 2, 2)
@@ -113,14 +127,14 @@ def show_with_diff(image, reference, title):
     plt.suptitle(title, size=16)
     plt.subplots_adjust(0.02, 0.02, 0.98, 0.79, 0.02, 0.2)
 
-show_with_diff(distorted, lena, 'Distorted image')
+show_with_diff(distorted, face, 'Distorted image')
 
 ###############################################################################
 # Extract noisy patches and reconstruct them using the dictionary
 
 print('Extracting noisy patches... ')
 t0 = time()
-data = extract_patches_2d(distorted[:, height // 2:], patch_size)
+data = extract_patches_2d(distorted[:, width // 2:], patch_size)
 data = data.reshape(data.shape[0], -1)
 intercept = np.mean(data, axis=0)
 data -= intercept
@@ -138,7 +152,7 @@ def show_with_diff(image, reference, title):
 reconstructions = {}
 for title, transform_algorithm, kwargs in transform_algorithms:
     print(title + '...')
-    reconstructions[title] = lena.copy()
+    reconstructions[title] = face.copy()
     t0 = time()
     dico.set_params(transform_algorithm=transform_algorithm, **kwargs)
     code = dico.transform(data)
@@ -149,11 +163,11 @@ def show_with_diff(image, reference, title):
     if transform_algorithm == 'threshold':
         patches -= patches.min()
         patches /= patches.max()
-    reconstructions[title][:, height // 2:] = reconstruct_from_patches_2d(
-        patches, (width, height // 2))
+    reconstructions[title][:, width // 2:] = reconstruct_from_patches_2d(
+        patches, (height, width // 2))
     dt = time() - t0
     print('done in %.2fs.' % dt)
-    show_with_diff(reconstructions[title], lena,
+    show_with_diff(reconstructions[title], face,
                    title + ' (time: %.1fs)' % dt)
 
 plt.show()