In [2]:
import tensorflow as tf
from tensorflow.keras import layers

import numpy as np

import plotly
import plotly.graph_objs as go

plotly.offline.init_notebook_mode(connected=True)
In [3]:
def NLclassifier(x,y):
    
    out = 0 
    
    if ((x**2 + 2*y**2 > 1) and (x**2 + 2*y**2 < 3)):
        out = 1
    
    if (x**2 + 2*y**2 >= 3):
        out = 2
        
    return out
In [22]:
lower = -2.5
upper = -lower

train_npts = 10000

data_train = np.random.uniform(lower , upper , 2 * train_npts).reshape(train_npts , 2)
outcolor = np.array(
    list(
        map(lambda x , y : NLclassifier(x,y) , data_train[:,0], data_train[:,1])))
In [23]:
# we create a dictionary to transform the classifier into a binary vector to apply softmax
classtovector = {0.0:np.array([1.0,0,0]), 1.0 : np.array([0,1.0,0]) , 2.0 :np.array([0,0,1.0])}

# our vectors are always column matrices
labels = np.array(list(map(lambda x : classtovector[x] , outcolor[:])))
In [24]:
labels.shape
Out[24]:
(10000, 3)
In [25]:
class0 = data_train[outcolor[:]==0,:]
print(class0.shape)

class1 = data_train[outcolor[:]==1,:]
print(class1.shape)

class2 = data_train[outcolor[:]==2,:]
print(class2.shape)

print(class0.shape[0] + class1.shape[0] + class2.shape[0])

(891, 2)
(1705, 2)
(7404, 2)
10000
In [26]:
x0 = class0[:,0]
y0 = class0[:,1]

trace0 = go.Scatter(
    x = x0,
    y = y0,
    name = 'Class 0',
    mode = 'markers',
    marker = dict(
        size = 5,
        color = 'rgba(203, 119, 111, .8)',
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)

x1 = class1[:,0]
y1 = class1[:,1]

trace1 = go.Scatter(
    x = x1,
    y = y1,
    name = 'Class 1',
    mode = 'markers',
    marker = dict(
        size = 5,
        color = 'rgba(209, 207 , 250, .8)',
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)

x2 = class2[:,0]
y2 = class2[:,1]

trace2 = go.Scatter(
    x = x2,
    y = y2,
    name = 'Class 2',
    mode = 'markers',
    marker = dict(
        size = 5,  
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)


plotdata_train = [trace0,trace1,trace2]

plotly.offline.iplot(plotdata_train)
In [80]:
model = tf.keras.Sequential()

model.add(layers.Dense(36,activation = 'relu',kernel_regularizer = tf.keras.regularizers.l2(0.00001)))
model.add(layers.Dense(36,activation = 'relu',kernel_regularizer = tf.keras.regularizers.l2(0.00001)))

model.add(layers.Dense(3,activation = 'softmax'))

model.compile(
    optimizer = tf.train.AdamOptimizer(0.001),
    loss = 'categorical_crossentropy',
    metrics=['accuracy']
)
In [81]:
model.fit(data_train,labels,epochs=10,batch_size=50)

Epoch 1/10
10000/10000 [==============================] - 1s 114us/step - loss: 0.5665 - acc: 0.7288
Epoch 2/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.3661 - acc: 0.7664
Epoch 3/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.2540 - acc: 0.8698
Epoch 4/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.1701 - acc: 0.9608
Epoch 5/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.1109 - acc: 0.9825
Epoch 6/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.0812 - acc: 0.9888
Epoch 7/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.0659 - acc: 0.9902
Epoch 8/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.0573 - acc: 0.9901
Epoch 9/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.0514 - acc: 0.9904
Epoch 10/10
10000/10000 [==============================] - 0s 35us/step - loss: 0.0463 - acc: 0.9914
Out[81]:
<tensorflow.python.keras.callbacks.History at 0xb453752e8>
In [104]:
test_npts = 5000

data_test = np.random.uniform(lower,upper,2 * test_npts).reshape(test_npts,2)

labels_test = np.array(
    list(map(lambda x,y : classtovector[NLclassifier(x,y)] , data_test[:,0] , data_test[:,1])
    )
)
In [105]:
model.evaluate(data_test,labels_test,batch_size=32)

5000/5000 [==============================] - 0s 22us/step
Out[105]:
[0.050164313924312594, 0.9868]
In [106]:
test_result = model.predict(data_test,batch_size = 32)
test_result.shape
Out[106]:
(5000, 3)
In [107]:
test_color = np.apply_along_axis(np.argmax,1,test_result)
In [108]:
test0 = data_test[test_color[:]==0,:]
print(test0.shape)

test1 = data_test[test_color[:]==1,:]
print(test1.shape)

test2 = data_test[test_color[:]==2,:]
print(test2.shape)

(461, 2)
(850, 2)
(3689, 2)
In [109]:
xx0 = test0[:,0]
yy0 = test0[:,1]

ttrace0 = go.Scatter(
    x = xx0,
    y = yy0,
    name = 'Class 0',
    mode = 'markers',
    marker = dict(
        size = 5,
        color = 'rgba(203, 119, 111, .8)',
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)

xx1 = test1[:,0]
yy1 = test1[:,1]

ttrace1 = go.Scatter(
    x = xx1,
    y = yy1,
    name = 'Class 1',
    mode = 'markers',
    marker = dict(
        size = 5,
        color = 'rgba(209, 207 , 250, .8)',
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)

xx2 = test2[:,0]
yy2 = test2[:,1]

ttrace2 = go.Scatter(
    x = xx2,
    y = yy2,
    name = 'Class 2',
    mode = 'markers',
    marker = dict(
        size = 5,
        line = dict(
            width = 1,
            color = 'rgb(0, 0, 0)'
        )
    )
)


plotdata_test = [ttrace0,ttrace1,ttrace2]

plotly.offline.iplot(plotdata_test)
In [ ]: