## How to predict wine-class (wine data) using a keras deep learning model

def Snippet_339(): 

    print()
    print(format('How to predict wine-class (wine data) using a keras deep learning model','*^88'))

    import warnings
    warnings.filterwarnings("ignore")

    # load libraries
    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from keras.utils import np_utils
    from keras.models import Sequential
    from keras.layers.core import Dense, Activation
    from keras.optimizers import SGD, RMSprop, Adam
    from keras.regularizers import l2
    import matplotlib.pyplot as plt    

    import time
    start_time = time.time()

    # set parameters
    NB_CLASSES = 3
    VALIDATION_SPLIT = 0.25
    VERBOSE = 1
    BATCH_SIZE = 128

    # load Dataset    
    iris = datasets.load_wine()
    X = iris.data
    y = iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
    
    # Preprocess The X Data By Scaling
    sc = StandardScaler(with_mean=True, with_std=True)
    sc.fit(X_train)

    # Apply the scaler to the X training data
    X_train_std = sc.transform(X_train)

    # Apply the SAME scaler to the X test data
    X_test_std = sc.transform(X_test)
    
    # -----------------------------------------------
    # convert class vectors to binary class matrices
    # -----------------------------------------------
    Y_train = np_utils.to_categorical(y_train, NB_CLASSES)
    Y_test  = np_utils.to_categorical(y_test, NB_CLASSES)

    # ---------------------------------------------------------------------
    # setup a deep learning model
    # ---------------------------------------------------------------------
    accuracy = []
    for OPTIMIZER in [SGD(), RMSprop(), Adam()]: 
        for NB_EPOCH in [50,100,200]:
            for N_Units_in_Multiple_Layers in [64, 128, 256]:
                model = Sequential()
                model.add(Dense(units = N_Units_in_Multiple_Layers, input_shape=(X_train.shape[1],), 
                                kernel_regularizer=l2())) 
                model.add(Activation('relu'))
                model.add(Dense(units = N_Units_in_Multiple_Layers, kernel_regularizer=l2()))
                model.add(Activation('relu'))
                model.add(Dense(units = NB_CLASSES))
                model.add(Activation('softmax'))

                model.summary()
                
                model.compile(loss='categorical_crossentropy', optimizer=OPTIMIZER, metrics=['accuracy'])
                
                model.fit(X_train_std, Y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH,
                          verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
                
                score = model.evaluate(X_test_std, Y_test, verbose=VERBOSE)
                
                print()
                print('Optimizers: ', OPTIMIZER)
                print('Epoch Sizes: ', NB_EPOCH)            
                print('Neurons or Units: ', N_Units_in_Multiple_Layers)            
                print("Test score:", score[0])
                print('Test accuracy:', score[1])
                accuracy.append(score[1])
                print()

    print(accuracy)
    y = accuracy; N = len(y); x = range(N); width = 1./1.5;
    plt.ylim(0.75,1.1)
    plt.bar(x,y,width); plt.show()

    print()
    print("Execution Time %s seconds: " % (time.time() - start_time))    

Snippet_339()