Merge branch 'master' into feature/generate_hastie_10_2

Author: filipebraida

README.md

@@ -41,11 +41,18 @@ make_classification  | Generate a random n-class classification problem.
 make_low_rank_matrix | Generate a mostly low rank matrix with bell-shaped singular values.     | [link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_low_rank_matrix.html)
 make_swiss_roll      | Generate a swiss roll dataset.                                          | [link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_swiss_roll.html)
 make_hastie_10_2     | Generates data for binary classification used in Hastie et al.          |[link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_hastie_10_2.html)
+make_gaussian_quantiles | Generate a swiss roll dataset.                                          | [link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_gaussian_quantiles.html)
 
 **Disclaimer**: SyntheticDatasets.jl borrows code and documentation from
 [scikit-learn](https://scikit-learn.org/stable/modules/classes.html#samples-generator) in the dataset module, but *it is not an official part
 of that project*. It is licensed under [MIT](LICENSE).
 
+### Other Functions
+
+Dataset              | Title                                                                   | Reference
+---------------------|-------------------------------------------------------------------------|--------------------------------------------------
+generate_twospirals  | Generate two spirals dataset.                                           | [link](https://la.mathworks.com/matlabcentral/fileexchange/41459-6-functions-for-generating-artificial-datasets)
+
 [travis-img]: https://travis-ci.com/ATISLabs/SyntheticDatasets.jl.svg?branch=master
 [travis-url]: https://travis-ci.com/ATISLabs/SyntheticDatasets.jl
 

src/SyntheticDatasets.jl

@@ -11,6 +11,7 @@ function __init__()
 end
 
 include("sklearn.jl")
+include("matlab.jl")
 
 function convert(features::Array{T, 2}, labels::Array{D, 1})::DataFrame where {T <: Number, D <: Number}
     df = DataFrame()

src/matlab.jl

@@ -0,0 +1,33 @@
+"""
+    generate_twospirals(;    n_samples::Int = 2000,
+                             start_degrees::Int = 90,
+                             total_degrees::Int = 570,
+                             noise::Float64 = 0.2
+Generate two spirals dataset. Return a Nx3 matrix, where each line contains the X,Y coordinates and the class of an instance.
+# Arguments
+- `n_samples::Int = 2000`: The total number of points generated.
+- `start_degrees::Int = 90`: Determines how far from the origin the spirals start.
+- `total_degrees::Int = 570`: Controls the lenght of the spirals.
+- `noise::Float64 = 0.2`: Determines the noise in the dataset.
+Reference: [link](https://la.mathworks.com/matlabcentral/fileexchange/41459-6-functions-for-generating-artificial-datasets)
+"""
+function generate_twospirals(; n_samples::Int = 2000,
+                               start_degrees::Int = 90,
+                               total_degrees::Int = 570,
+                               noise::Float64 = 0.2)
+   start_degrees = deg2rad(start_degrees);
+
+   N1 = floor(Int, n_samples / 2);
+   N2 = n_samples - N1;
+
+   n = start_degrees .+ sqrt.(rand(N1,1)) .* deg2rad(total_degrees);
+   d1 = [-cos.(n).*n + rand(N1,1).*noise sin.(n).*n+rand(N1,1).*noise];
+
+   n = start_degrees .+ sqrt.(rand(N2,1)) .* deg2rad(total_degrees);
+   d2 = [cos.(n).*n+rand(N2,1)*noise -sin.(n).*n+rand(N2,1)*noise];
+
+   features = [d1; d2]
+   labels = [zeros(Int, N1); ones(Int, N1)]
+
+   return convert(features, labels);
+end

src/sklearn.jl

@@ -379,3 +379,42 @@ function generate_hastie_10_2(;  n_samples::Int = 12000,
 
    return convert(features, labels)
 end
+
+"""
+function generate_gaussian_quantiles(; mean::Array{<:Union{Number, Nothing}, 1} = [nothing],
+                                       cov::Float64 = 1,
+                                       n_samples::Int = 100,
+                                       n_features::Int = 2,
+                                       n_classes::Int = 3,
+                                       shuffle::Bool = true,
+                                       random_state::Union{Int, Nothing} = nothing)
+
+Generate isotropic Gaussian and label samples by quantile.
+#Arguments
+- `mean::Array{<:Union{Number, Nothing}, 1} = [nothing]`: The mean of the multi-dimensional normal distribution. If None then use the origin (0, 0, …).
+- `cov::Float64 = 1`: The covariance matrix will be this value times the unit matrix.
+- `n_samples::Int = 100`: The total number of points equally divided among classes.
+- `n_features::Int = 2`: The number of features for each sample.
+- `n_classes::Int = 3`: The number of classes.
+- `shuffle::Bool = true`: Shuffle the samples.
+- `random_state::Union{Int, Nothing} = nothing`: Determines random number generation for dataset creation. Pass an int for reproducible output across multiple function calls. See Glossary.
+Reference: [link](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_gaussian_quantiles.html)
+"""
+function generate_gaussian_quantiles(; mean::Union{Array{<:Number, 1}, Nothing} = nothing,
+                                       cov::Float64 = 1.0,
+                                       n_samples::Int = 100,
+                                       n_features::Int = 2,
+                                       n_classes::Int = 3,
+                                       shuffle::Bool = true,
+                                       random_state::Union{Int, Nothing} = nothing)
+
+    (features, labels) = datasets.make_gaussian_quantiles(mean = mean,
+                                                          cov = cov,
+                                                          n_samples = n_samples,
+                                                          n_features = n_features,
+                                                          n_classes = n_classes,
+                                                          shuffle = shuffle,
+                                                          random_state = random_state)
+
+    return convert(features, labels)
+end

test/runtests.jl

@@ -40,15 +40,15 @@ using Test
     @test size(data)[1] == samples
     @test size(data)[2] == features + 1
 
-    data = SyntheticDatasets.generate_classification(n_samples = samples,
-                                                    n_features = features,
-                                                    n_classes = 1)
+    data = SyntheticDatasets.generate_classification(   n_samples = samples,
+                                                        n_features = features,
+                                                        n_classes = 1)
 
     @test size(data)[1] == samples
     @test size(data)[2] == features + 1
 
     data = SyntheticDatasets.generate_friedman1(n_samples = samples,
-                                                    n_features = features)
+                                                n_features = features)
 
     @test size(data)[1] == samples
     @test size(data)[2] == features + 1
@@ -63,11 +63,11 @@ using Test
     @test size(data)[1] == samples
     @test size(data)[2] == 5
 
-    data = SyntheticDatasets.generate_low_rank_matrix(n_samples = samples,
-                                                    n_features = features,
-                                                    effective_rank = 10,
-                                                    tail_strength = 0.5,
-                                                    random_state = 5)
+    data = SyntheticDatasets.generate_low_rank_matrix(  n_samples = samples,
+                                                        n_features = features,
+                                                        effective_rank = 10,
+                                                        tail_strength = 0.5,
+                                                        random_state = 5)
 
     @test size(data)[1] == samples
     @test size(data)[2] == features
@@ -79,9 +79,25 @@ using Test
     @test size(data)[1] == samples
     @test size(data)[2] == 4
 
-    data = SyntheticDatasets.generate_hastie_10_2(n_samples = samples,
-                                                random_state = 5)
+    data = SyntheticDatasets.generate_hastie_10_2(  n_samples = samples,
+                                                    random_state = 5)
 
     @test size(data)[1] == samples
     @test size(data)[2] == 11
+
+    data = SyntheticDatasets.generate_gaussian_quantiles(   n_samples = samples,
+                                                            n_features = features,
+                                                            random_state = 5)
+
+    @test size(data)[1] == samples
+    @test size(data)[2] == features + 1
+end
+
+@testset "Matlab Generators" begin
+    samples = 20000
+
+    data = SyntheticDatasets.generate_twospirals(n_samples = samples,
+                                                 noise = 2.2)
+
+    @test size(data)[1] == samples
 end