playground-data 1.2.0__py3-none-any.whl

plygdata/datahelper.py

@@ -0,0 +1,236 @@
+# ==============================================================================
+# Copyright 2018-2019 Digital Advantage Co., Ltd. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from __future__ import division
+
+import matplotlib.pyplot as plt
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+import numpy as np
+from plygdata.dataset import generate_data
+from plygdata.state import InputType
+from plygdata.heatmap import HeatMap
+from plygdata.playground import Player
+
+
+POINT_DOMAIN = [-6.0, 6.0]
+TICKS_POINT = [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6]
+TICKS_MIDDLE = 6
+TICKS_VALUE = [-1, 0, 1]
+
+
+def split_data(data, validation_size=0.5, label_num=1, training_size=-1.0):
+    '''
+    Split data int training and validation data. And Each data will be split into input data and teacher labels.
+    :param data:
+    :param validation_size:
+    :param label_num:
+    :param training_size:
+    :return: (X_train, y_train, X_valid, y_valid)
+    '''
+
+    len_data = len(data)
+    if len_data == 0:
+        raise ValueError("No array error.")
+
+    mat = np.array(data)
+
+    # It is easy to use scikit-learn.
+    # X = mat[:,:-(label_num)] # data
+    # y = mat[:,-(label_num)]  # label
+    # from sklearn.model_selection import train_test_split
+    # X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=validation_size)
+
+    # But, because this class doesn't use scikit-learn.
+    np.random.shuffle(mat)
+
+    X = mat[:, :-(label_num)]  # data
+    y = mat[:, -label_num:]   # labels
+
+    if training_size >= 0.0 and training_size <= 1.0:
+        validation_size = 1.0 - training_size
+
+    split_point = round(len(mat) * (1.0 - validation_size))
+    X_train = X[0:split_point, :] # train data
+    y_train = y[0:split_point]    # train label
+    X_valid = X[split_point:, :]   # validation data
+    y_valid = y[split_point:]      # validation label
+
+    if label_num == 1:
+        y_train = np.reshape(y_train, [len(y_train), 1])
+        y_valid = np.reshape(y_valid, [len(y_valid), 1])
+
+    # To Pandas example:
+    # import numpy as np
+    # import pandas as pd
+    # df_X_train = pd.DataFrame(X_train)
+    # df_X_train.columns = ['x1', 'x2']
+    # print(df_X_train)
+    # df_y_train = pd.DataFrame(y_train)
+    # df_y_train.columns = ['label']
+    # print(df_y_train)
+
+    return X_train, y_train, X_valid, y_valid
+
+
+def get_playground_figure(enable_colorbar=False):
+    if enable_colorbar:
+        fig = plt.figure(figsize=(6, 6), dpi=100)
+    else:
+        fig = plt.figure(figsize=(5, 5), dpi=100)
+    return fig
+
+
+def get_playground_axes(fig):
+    ax = fig.add_subplot(111)  # Row: 1, Column: 1, Place: 1
+    ax.set_facecolor("#e8eaeb")
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    ax.spines['bottom'].set_visible(False)
+    ax.spines['left'].set_visible(False)
+    ax.yaxis.tick_right()
+    ax.tick_params(axis='x', colors='#bbbbbb')
+    ax.tick_params(axis='y', colors='#bbbbbb')
+    ax.set_xlim(POINT_DOMAIN)
+    ax.set_ylim(POINT_DOMAIN)
+    ax.set_xticks(TICKS_POINT)
+    ax.set_yticks(TICKS_POINT)
+    ax.get_xticklabels()[TICKS_MIDDLE].set_color("#333333")
+    ax.get_yticklabels()[TICKS_MIDDLE].set_color("#333333")
+    #ax.grid(color='white', linestyle='-')
+    ax.grid(visible=False)
+    return ax
+
+
+def plot_points(ax, X_train, y_train, X_valid=None, y_valid=None):
+
+    HeatMap.updateTrainPoints(ax, X_train, y_train)
+
+    if all([X_valid is not None, y_valid is not None]):
+        HeatMap.updateValidationPoints(ax, X_valid, y_valid)
+
+
+def plot_points_with_playground_style(X_train, y_train, X_valid=None, y_valid=None, figsize=(5, 5), dpi=100):
+    """
+    if width 5 inches x height 5 inches x dpi 100, = 500 x 500 dots figure will be created.
+
+    :param X_train: train data
+    :param y_train: grain label
+    :param X_valid: validation data
+    :param y_valid: validation label
+    :param figsize: width inches (default: 5) x height (default: 5) inches
+    :param dpi: dpi (default: 100)
+    :return: a Figure object of matplotlib,  and the axes (Coordinate axis)
+    """
+    fig = plt.figure(figsize=figsize, dpi=dpi)
+
+    # get the axes (Coordinate axis) designed for NeuralNetwork Playground of Deep Insider.
+    ax = get_playground_axes(fig)
+
+    plot_points(ax, X_train, y_train, X_valid, y_valid)
+
+    return fig, ax
+
+
+def _add_colorbar_on_bottom(fig, ax, im):
+    divider = make_axes_locatable(ax)
+    ax_cb = divider.append_axes("bottom", size="5%", pad=0.3)
+    ax_cb.tick_params(axis='x', colors='#777777')
+    ax_cb.tick_params(axis='y', colors='#777777')
+    cb = fig.colorbar(im, cax=ax_cb, ticks=TICKS_VALUE, orientation='horizontal')
+    cb.outline.set_edgecolor('white')
+    cb.outline.set_linewidth(0)
+    cb.solids.set_edgecolor("face")
+    ax_cb.xaxis.set_ticks_position("bottom")
+
+
+def plot_sample(data_type, noise=0.0, validation_size=0.5, visualize_validation_data=False, figsize=(5, 5), dpi=100, node_id=None, discretize=False, training_size=-1.0):
+
+    data_array = generate_data(data_type, noise)
+    if data_array is None:
+        return None, None
+
+    mat = np.array(data_array)
+    X_train, y_train, X_valid, y_valid = split_data(mat, validation_size=validation_size, training_size=training_size)
+
+    fig, ax = plot_points_with_playground_style(X_train, y_train, X_valid if (visualize_validation_data) else None, y_valid if (visualize_validation_data) else None, figsize=figsize, dpi=dpi)
+
+    if node_id is not None:
+        draw_decision_boundary(fig, ax, node_id=node_id, discretize=discretize)
+
+    return fig, ax
+
+
+def predict_classes(trained_model, x, batch_size=32, verbose=0):
+    """Generate class predictions for the input samples.
+    The input samples are processed batch by batch.
+    # Arguments
+        x: input data, as a Numpy array or list of Numpy arrays
+            (if the trained_model has multiple inputs).
+        batch_size: integer.
+        verbose: verbosity mode, 0 or 1.
+    # Returns:
+        A numpy array of class predictions.
+    """
+    preds = trained_model.predict(x, batch_size=batch_size, verbose=verbose)
+    discretized = np.where(preds >= 0.0, 1, -1)
+    return discretized
+
+
+def predict_proba(trained_model, x, batch_size=32, verbose=0):
+    """Generates class probability predictions for the input samples.
+    The input samples are processed batch by batch.
+    # Arguments
+        x: input data, as a Numpy array or list of Numpy arrays
+            (if the trained_model has multiple inputs).
+        batch_size: integer.
+        verbose: verbosity mode, 0 or 1.
+    # Returns
+        A Numpy array of probability predictions.
+    """
+    probability = trained_model.predict(x, batch_size=batch_size, verbose=verbose)
+    return probability
+
+
+def predict_classes_proba(trained_model, x, batch_size=32, verbose=0):
+    """Generate class and probability predictions for the input samples.
+    The input samples are processed batch by batch.
+    # Arguments
+        x: input data, as a Numpy array or list of Numpy arrays
+            (if the trained_model has multiple inputs).
+        batch_size: integer.
+        verbose: verbosity mode, 0 or 1.
+    # Returns:
+        A numpy array of class and probability predictions.
+    """
+    probability = trained_model.predict(x, batch_size=batch_size, verbose=verbose)
+    discretized = np.where(probability >= 0.0, 1, -1)
+    return discretized, probability
+
+
+def draw_decision_boundary(fig, ax, node_id=InputType.X1, trained_model=None, discretize=False, enable_colorbar=True):
+
+    if trained_model is None:
+        im = HeatMap.updateBackground(ax, None, node_id, discretize)
+    else:
+        boundary_array = Player.get_boundary_array()
+        probability = predict_proba(trained_model, boundary_array)
+        im = HeatMap.updateBackground(ax, None, None, discretize, probability)
+
+    if enable_colorbar:
+        _add_colorbar_on_bottom(fig, ax, im)
+
+    return im
+

plygdata/dataset.py

@@ -0,0 +1,268 @@
+# ==============================================================================
+# Copyright 2018-2019 Digital Advantage Co., Ltd. All Rights Reserved.
+#
+# This is a Python implementation of [tensorflow / playground (Deep playground) / dataset.ts](https://github.com/tensorflow/playground/blob/master/src/dataset.ts).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from __future__ import division
+
+import random
+import math
+from plygdata.scalelinear import ScaleLinear
+from plygdata.state import DatasetType
+
+
+NUM_SAMPLES_CLASSIFY = 500
+NUM_SAMPLES_REGRESS = 1200
+
+
+#class Example2D:
+#    """
+#    A two dimensional example: x and y coordinates with the label.
+#    """
+#    def __init__(self, x=0, y=0, label=0) :
+#        self.x = x
+#        self.y = y
+#        self.label = label
+
+class Point:
+    def __init__(self, x = 0.0, y = 0.0):
+        self.x = x
+        self.y = y
+
+
+def rand_uniform(a, b):
+    """
+    Returns a sample from a uniform [a, b] distribution.
+    """
+    return random.random() * (b - a) + a
+
+
+def normal_random(mean = 0.0, variance = 1.0):
+    """
+        Samples from a normal distribution.
+
+        :param mean
+            The mean. Default is 0.0.
+        :param variance
+            The variance. Default is 1.0.
+    """
+    while True:
+        v1 = 2.0 * random.random() - 1.0
+        v2 = 2.0 * random.random() - 1.0
+        s = v1 * v1 + v2 * v2
+        if 0.0 < s <= 1.0:
+            break
+    result = math.sqrt(-2.0 * math.log(s) / s) * v1
+    return mean + math.sqrt(variance) * result
+
+
+def dist(a, b):
+    """
+    Returns the euclidean distance between two points in space.
+    """
+    dx = a.x - b.x
+    dy = a.y - b.y
+    return math.sqrt(dx * dx + dy * dy)
+
+
+def shuffle(array):
+    """
+    Shuffles the array using Fisher-Yates algorithm. Uses the seedrandom
+    library as the random generator.
+    """
+    counter = len(array)
+    temp = 0
+    index = 0
+    # While there are elements in the array
+    while counter > 0:
+        # Pick a random index
+        index = int(math.floor(random.random() * counter))
+        # Decrease counter by 1
+        counter -= 1
+        # And swap the last element with it
+        temp = array[counter]
+        array[counter] = array[index]
+        array[index] = temp
+
+
+def generate_data(data_type, noise = 0.0):
+
+    if data_type == DatasetType.ClassifyTwoGaussData:
+        data_array = DataGenerator.classify_two_gauss(NUM_SAMPLES_CLASSIFY, noise=noise)
+    elif data_type == DatasetType.ClassifyXORData:
+        data_array = DataGenerator.classify_xor(NUM_SAMPLES_CLASSIFY, noise=noise)
+    elif data_type == DatasetType.ClassifyCircleData:
+        data_array = DataGenerator.classify_circle(NUM_SAMPLES_CLASSIFY, noise=noise)
+    elif data_type == DatasetType.ClassifySpiralData:
+        data_array = DataGenerator.classify_spiral(NUM_SAMPLES_CLASSIFY, noise=noise)
+    elif data_type == DatasetType.RegressPlane:
+        data_array = DataGenerator.regress_plane(NUM_SAMPLES_REGRESS, noise=noise)
+    elif data_type == DatasetType.RegressGaussian:
+        data_array = DataGenerator.regress_gaussian(NUM_SAMPLES_REGRESS, noise=noise)
+    else:
+        return None
+
+    return data_array
+
+
+class DataGenerator:
+
+    @staticmethod
+    def classify_two_gauss(numSamples, noise = 0.0):
+        points = []
+
+        varianceScale = ScaleLinear(domain=[0.0, 0.5], slrange=[0.5, 4.0])
+        variance = varianceScale(noise)
+
+        def genGauss(cx, cy, label):
+            for _ in range(numSamples // 2):
+                x = normal_random(cx, variance)
+                y = normal_random(cy, variance)
+                points.append([x, y, label])
+
+        genGauss(2.0, 2.0, 1) # Gaussian with positive examples.
+        genGauss(-2.0, -2.0, -1) # Gaussian with negative examples.
+        return points
+
+
+    @staticmethod
+    def classify_xor(numSamples, noise = 0.0):
+
+        def getXORLabel(p):
+            return 1 if (p.x * p.y >= 0) else -1
+
+        points = []
+        for _ in range(numSamples):
+            x = rand_uniform(-5.0, 5.0)
+            padding = 0.3
+            x = x + padding if (x > 0) else x - padding  # Padding.
+            y = rand_uniform(-5.0, 5.0)
+            y = y + padding if (y > 0) else y - padding
+            noiseX = rand_uniform(-5.0, 5.0) * noise
+            noiseY = rand_uniform(-5.0, 5.0) * noise
+            label = getXORLabel(Point(x + noiseX, y + noiseY))
+            points.append([x, y, label])
+        return points
+
+
+    @staticmethod
+    def classify_circle(numSamples, noise = 0.0):
+        points = []
+        radius = 5.0
+
+        def getCircleLabel(p, center):
+            return 1 if (dist(p, center) < (radius * 0.5)) else -1
+
+        # Generate positive points inside the circle.
+        for _ in range(numSamples // 2):
+            r = rand_uniform(0.0, radius * 0.5)
+            angle = rand_uniform(0.0, 2.0 * math.pi)
+            x = r * math.sin(angle)
+            y = r * math.cos(angle)
+            noiseX = rand_uniform(-radius, radius) * noise
+            noiseY = rand_uniform(-radius, radius) * noise
+            label = getCircleLabel(Point(x + noiseX, y + noiseY), Point(0.0, 0.0))
+            points.append([x, y, label])
+
+        # Generate negative points outside the circle.
+        for _ in range(numSamples // 2):
+            r = rand_uniform(radius * 0.7, radius)
+            angle = rand_uniform(0.0, 2.0 * math.pi)
+            x = r * math.sin(angle)
+            y = r * math.cos(angle)
+            noiseX = rand_uniform(-radius, radius) * noise
+            noiseY = rand_uniform(-radius, radius) * noise
+            label = getCircleLabel(Point(x + noiseX, y + noiseY), Point(0.0, 0.0))
+            points.append([x, y, label])
+
+        return points
+
+
+    @staticmethod
+    def classify_spiral(numSamples, noise = 0.0):
+        points = []
+        n = numSamples // 2
+
+        def genSpiral(deltaT, label):
+            for i in range(n):
+                r = i / n * 5
+                t = 1.75 * i / n * 2 * math.pi + deltaT
+                x = r * math.sin(t) + rand_uniform(-1.0, 1.0) * noise
+                y = r * math.cos(t) + rand_uniform(-1.0, 1.0) * noise
+                points.append([x, y, label])
+
+        genSpiral(0.0, 1)  # Positive examples.
+        genSpiral(math.pi, -1)  # Negative examples.
+
+        return points
+
+
+    @staticmethod
+    def regress_plane(numSamples, noise = 0.0):
+        radius = 6
+        labelScale = ScaleLinear(domain=[-10, 10], slrange=[-1, 1])
+        getLabel = lambda x, y: labelScale(x + y)
+
+        points = []
+        for _ in range(numSamples):
+            x = rand_uniform(-radius, radius)
+            y = rand_uniform(-radius, radius)
+            noiseX = rand_uniform(-radius, radius) * noise
+            noiseY = rand_uniform(-radius, radius) * noise
+            label = getLabel(x + noiseX, y + noiseY)
+            points.append([x, y, label])
+
+        return points
+
+
+    @staticmethod
+    def regress_gaussian(numSamples, noise = 0.0):
+        points = []
+        
+        labelScale = ScaleLinear(domain=[0.0, 2.0], slrange=[1.0, 0.0], clamp=True)
+        
+        gaussians = [
+            [-4.0,  2.5,  1.0],
+            [ 0.0,  2.5, -1.0],
+            [ 4.0,  2.5,  1.0],
+            [-4.0, -2.5, -1.0],
+            [ 0.0, -2.5,  1.0],
+            [ 4.0, -2.5, -1.0]
+        ]
+        
+        def getLabel(x, y):
+        # Choose the one that is maximum in abs value.
+            curlabel = 0
+            for c in gaussians:
+                cx = c[0]
+                cy = c[1]
+                sign = c[2]
+                newLabel = sign * labelScale(dist(Point(x, y), Point(cx, cy)))
+                if abs(newLabel) > abs(curlabel):
+                    curlabel = newLabel
+            return curlabel
+        
+        radius = 6.0
+        for _ in range(numSamples):
+            x = rand_uniform(-radius, radius)
+            y = rand_uniform(-radius, radius)
+            noiseX = rand_uniform(-radius, radius) * noise
+            noiseY = rand_uniform(-radius, radius) * noise
+            label = getLabel(x + noiseX, y + noiseY)
+            points.append([x, y, label])
+        
+        return points
+

plygdata/heatmap.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# Copyright 2018-2019 Digital Advantage Co., Ltd. All Rights Reserved.
+#
+# This is a Python implementation of [tensorflow / playground (Deep playground) / heatmap.ts](https://github.com/tensorflow/playground/blob/master/src/heatmap.ts).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from __future__ import division
+
+from plygdata.datacolor import DataColor
+from plygdata.playground import Player
+
+
+RECT_DOMAIN = [-6.0, 6.0, -6.0, 6.0]
+
+
+class HeatMap:
+    '''
+     Draws a heatmap using matplotlib.
+     Used for showing the learned decision boundary of the classification algorithm.
+     Can also draw data points on top of the heatmap figure using matplotlib.
+    '''
+
+    @staticmethod
+    def draw_decision_boundary_of_node(ax, boundary_of_node):
+        cmap, norm = DataColor.get_colormap()
+        alpha = (160 / 255)
+        im = ax.imshow(boundary_of_node, extent=RECT_DOMAIN, cmap=cmap, norm=norm, alpha=alpha, interpolation='bicubic')
+        return im
+
+
+    @staticmethod
+    def updateBackground(ax, boundaries, node_id, discretize, probability=None):
+        if probability is None:
+          boundaries = Player.update_decision_boundary(boundaries, discretize)
+          boundary_of_node = boundaries[node_id]
+        else:
+          boundary_of_node = Player.get_decision_boundary_of_node(probability, discretize)
+        im = HeatMap.draw_decision_boundary_of_node(ax, boundary_of_node)
+        return im
+
+
+    @staticmethod
+    def updateCircles(ax, X_points, y_label, edgecolors):
+        for i in range(len(X_points)):
+            ax.scatter(X_points[i, 0], X_points[i, 1], s=20, c=DataColor.get_rgb(y_label[i].item()), alpha=0.9, linewidths=0.7, edgecolors=edgecolors)
+
+
+    @staticmethod
+    def updateTrainPoints(ax, X_train, y_train):
+        HeatMap.updateCircles(ax, X_train, y_train, "#ffffff")
+
+
+    @staticmethod
+    def updateValidationPoints(ax, X_valid, y_valid):
+        HeatMap.updateCircles(ax, X_valid, y_valid, "#555555")
+
+
+    @staticmethod
+    def updateTestPoints(ax, X_valid, y_valid):
+        HeatMap.updateCircles(ax, X_valid, y_valid, "#FF5555")
+
+
+    @staticmethod
+    def reduceMatrix(matrix, factor):
+
+        len_matrix = len(matrix)
+        if not isinstance(factor, int) or isinstance(factor, bool) or factor <= 0:
+            raise ValueError("The reduction factor must be a positive integer")
+        if not len_matrix or any(len(row) != len_matrix for row in matrix):
+            raise ValueError("The provided matrix must be a nonempty square matrix")
+        if len_matrix % factor:
+            raise ValueError("The width/height of the matrix must be divisible by the reduction factor")
+        return [
+            [sum(matrix[i + k][j + l] for k in range(factor) for l in range(factor))
+             / (factor * factor) for j in range(0, len_matrix, factor)]
+            for i in range(0, len_matrix, factor)
+        ]