Why this single layer network does'nt work
I can't find the code in the link you posted to get more background information on what kind of data source it is that you are using.

However, a data source that is $60\times60\times3$ is described as being high dimensional. You have a total of 10,800 input features which need to be mapped down to 17 different classes. This is actually a very complex task and will not be successful using a single layer network. Such a simple network will not have enough parameters to capture the non-linearities between features in your input space. 

That being said, if you insist on using a single layer network with a data of size $60\times60\times3$ with 17 input classes the code is as follows.

Let's first create some artificial data of the same dimension as your data

import numpy as np

n = 1000
x_train = np.zeros((n,64,64,3))
y_train = np.zeros((n,))
for i in range(n):
    x_train[i,:,:,:] = np.random.random((64,64,3))
    y_train[i] = np.random.randint(0,17)

x_train = x_train.reshape(n,64,64,3,)

n = 100
x_test = np.zeros((n,64,64,3))
y_test = np.zeros((n,))
for i in range(n):
    x_test[i,:,:,:] = np.random.random((64,64,3))
    y_test[i] = np.random.randint(0,17)

x_test = x_test.reshape(n,64,64,3,)

print('Training data: ', x_train.shape)
print('Training labels: ', y_train.shape)
print('Testing data: ', x_test.shape)
print('Testing labels: ', y_test.shape)



  (1000, 64, 64, 3) 
  (1000,) 
  (100, 64, 64, 3) 
  (100,)


For a classification task we should convert our outputs to categorical vectors. Where we use one-hot encoding to identify the correct class.

import keras

# The known number of output classes.
num_classes = 17

# Convert class vectors to binary class matrices. This uses 1 hot encoding.
y_train_binary = keras.utils.to_categorical(y_train, num_classes)
y_test_binary = keras.utils.to_categorical(y_test, num_classes)


We then build the model. 

from __future__ import print_function
import keras
from keras.models import Sequential
from keras.layers import Dense, Flatten
from keras.models import model_from_json
from keras import backend as K

input_shape = (64,64,3,)

model = Sequential()
model.add(Flatten(input_shape=input_shape))
model.add(Dense(17, activation='softmax'))


model.compile(loss=keras.losses.mean_squared_error,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])


You can see the summary of the model by using 

model.summary()


Then we can train this model using

batch_size = 128
epochs = 10
model.fit(x_train, y_train_binary,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(x_test, y_test_binary))


This code works. However, the data is completely random thus the model cannot learn anything. However, even if your data is easily distinguishable, as I said above, I do not expect this model to be complex enough to distinguish such a large input space from 17 different possible classes.

If you post the data source you are using we can design a model to get a good result.