import numpy as np
import math 
import sys
import time
import tensorflow
# from sklearn.datasets import fetch_mldata
from sklearn.datasets import fetch_openml
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler

from sklearn.cluster import KMeans
from sklearn.cluster import MiniBatchKMeans

from keras.datasets import mnist as kmnist
from scipy.special import expit  
from matplotlib import pyplot as plt
from symbol import except_clause
from IPython.core.tests.simpleerr import sysexit
from math import floor

    
    def __init__(self, 
                 my_data_set = "mnist",
                 
                 X_import = None, # imported X dataset 
                 y_import = None, # imported y dataset 
                 
                 num_test_records = 10000, # number of test data 
                 
                 # parameter for normalization of input data 
                 b_normalize_X = False, # True: apply StandardScaler on X input data
                 
                 # parameters for clustering of input data 
                 b_perform_clustering = False,  # shall we cluster the X_data before learning? 
                 my_clustering_method = "MiniBatchKMeans", # Choice between 2 methods: MiniBatchKMeans, KMeans  
                 cl_n_clusters = 200,      # number of clusters (often "k" in literature)
                 cl_max_iter = 600,        # number of iterations for centroid movement
                 cl_n_init = 100,          # number of different initial centroid positions tried 
                 cl_n_jobs = 4,            # number of CPU cores (jobs to start for investigating n_init variations
                 cl_batch_size = 500,      # batch size, only used for MiniBatchKMeans
                 
                 #parameters for PCA of input data 
                 b_
perform_pca = False,
                 num_pca_categories = 155, 
                 
                 # parameters for MLP structure
                 n_hidden_layers = 1, 
                 ay_nodes_layers = [0, 100, 0], # array which should have as much elements as n_hidden + 2
                 n_nodes_layer_out = 10,  # expected number of nodes in output layer 
                                                  
                 my_activation_function = "sigmoid", 
                 my_out_function        = "sigmoid",   
                 my_loss_function       = "LogLoss",   
                 
                 n_size_mini_batch = 50,  # number of data elements in a mini-batch 
                 
                 n_epochs      = 1,
                 n_max_batches = -1,  # number of mini-batches to use during epochs - > 0 only for testing 
                                      # a negative value uses all mini-batches 
                 
                 lambda2_reg = 0.1,     # factor for quadratic regularization term 
                 lambda1_reg = 0.0,     # factor for linear regularization term 
                 
                 vect_mode = 'cols', 
                 
                 init_weight_meth_L0 = "sqrt_nodes",  # method to init weights => "sqrt_nodes", "const"
                 init_weight_meth_Ln = "sqrt_nodes",  # sqrt_nodes", "const"
                 init_weight_intervals = [(-0.5, 0.5), (-0.5, 0.5), (-0.5, 0.5)],   # size must fit number of hidden layers
                 init_weight_fact = 2.0,                # extends the interval 
                 
                 
                 learn_rate = 0.001,          # the learning rate (often called epsilon in textbooks) 
                 decrease_const = 0.00001,    # a factor for decreasing the learning rate with epochs
                 learn_rate_limit = 2.0e-05,  # a lower limit for the learn rate 
                 adapt_with_acc = False,      # adapt learning rate with additional factor depending on rate of acc change
                 reduction_fact = 0.001,      # small reduction factor - should be around 0.001 because of an exponential reduction
                 
                 mom_rate   = 0.0005,         # a factor for momentum learning
                 
                 b_shuffle_batches = True,    # True: we mix the data for mini-batches in the X-train set at the start of each epoch
                 
                 b_predictions_train = False, # True: At the end of periodic epochs the code performs predictions on the train data set
                 b_predictions_test  = False, # True: At the end of periodic epochs the code performs predictions on the test data set
                 prediction_test_period  = 1, # Period of epochs for which we perform predictions
                 prediction_train_period = 1, # Period of epochs for which we perform predictions
                 
                 print_period = 20,         # number of epochs for which to print the costs and the averaged error
                 
                 figs_x1=12.0, figs_x2=8.0, 
                 legend_loc='upper right',
                 
                 b_print_test_data = True
                 
                 ):
        '''
        Initialization of MyANN
        Input: 
            data_set: type of dataset; so far only the "mnist", "mnist_784" datsets are known 
                      We use this information to prepare the input data and learn about the feature dimension. 
                      This info is used in preparing the size of the input layer.     
            
            X_import: external X dataset to import  
            y_import: external y dataset to import - must fit in dimension to X_import 
            
            num_test_records: number of test data
            
            b_normalize_X: True => Invoke the StandardScaler of 
Scikit-Learn 
                                   to center and normalize the input data X
            
            Preprocessing of input data treatment before learning 
            ------------------------------------
            Clustering
            -----------
            b_perform_clustering   # True => Cluster the X_data before learning? 
            my_clustering_method   # string: 2 methods: MiniBatchKMeans, KMeans 
            cl_n_clusters = 200       # number of clusters (often "k" in literature)
            cl_max_iter = 600      # number of iterations for centroid movement
            cl_n_init = 100        # number of different initial centroid positions tried 
            cl_n_jobs = 4,         # number of CPU cores => jobs - only used for "KMeans"
            cl_batch_size = 500    # batch size used for "MiniBatchKMeans"
            
            PCA
            -----
            b_perform_pca: True => perform a pca analysis 
            num_pca_categories: 155 - choose a reasonable number 
            
            n_hidden_layers = number of hidden layers => between input layer 0 and output layer n 
            
            ay_nodes_layers = [0, 100, 0 ] : We set the number of nodes in input layer_0 and the output_layer to zero 
                              Will be set to real number afterwards by infos from the input dataset. 
                              All other numbers are used for the node numbers of the hidden layers.
            n_nodes_out_layer = expected number of nodes in the output layer (is checked); 
                                this number corresponds to the number of categories NC = number of labels to be distinguished
            
            my_activation_function : name of the activation function to use 
            my_out_function : name of the "activation" function of the last layer which produces the output values 
            my_loss_function : name of the "cost" or "loss" function used for optimization 
            
            n_size_mini_batch : Number of elements/samples in a mini-batch of training data 
                                The number of mini-batches will be calculated from this
            
            n_epochs : number of epochs to calculate during training
            n_max_batches : > 0: maximum of mini-batches to use during training 
                            < 0: use all mini-batches  
            
            lambda_reg2:    The factor for the quadartic regularization term 
            lambda_reg1:    The factor for the linear regularization term 
            
            vect_mode: Are 1-dim data arrays (vctors) ordered by columns or rows ?
            
            init_weight_meth_L0: Method to calculate the initial weights at layer L0: "sqrt_nodes" => sqrt(number of nodes) /  "const" => interval borders 
            init_weight_meth_Ln: Method to calculate the initial weights at hidden layers 
            init_weight_intervals: list of tuples with interval limits [(-0.5, 0.5), (-0.5, 0.5), (-0.5, 0.5)],   
                                   size must fit number of hidden layers
            init_weight_fact:  interval limits get scald by this factor, e.g. 2* (0,5, 0.5)

            learn rate :     Learning rate - definies by how much we correct weights in the indicated direction of the gradient on the cost hyperplane.
            decrease_const:  Controls a systematic decrease of the learning rate with epoch number 
            learn_rate_limit = 2.0e-05,  # a lowee limit for the learning rate 
            
            adapt_with_acc:  True => adapt learning rate with additional factor depending on rate of acc change
            reduction_fact:  around 0.001  => almost exponential reduction during the first 500 epochs   
            
            mom_const:       Momentum rate. Controls a mixture of the last with the present weight 
corrections (momentum learning)
            
            b_shuffle_batches: True => vary composition of mini-batches with each epoch
            
            # The next two parameters enable the measurement of accuracy and total cost function 
            # by making predictions on the train and test datasets 
            b_predictions_train: True => perform a prediction run on the full training data set => get accuracy 
            b_predictions_test:  True => perform a prediction run on the full test data set => get accuracy 
            prediction_test_period: period of epochs for which to perform predictions
            prediction_train_period: period of epochs for which to perform predictions
            
            print_period:    number of periods between printing out some intermediate data 
                             on costs and the averaged error of the last mini-batch   
                       
            
            figs_x1=12.0, figs_x2=8.0 : Standard sizing of plots , 
            legend_loc='upper right': Position of legends in the plots
            
            b_print_test_data: Boolean variable to control the print out of some tests data 
             
         '''
        
        # Array (Python list) of known input data sets 
        self._input_data_sets = ["mnist", "mnist_784", "mnist_keras", "imported"]  
        self._my_data_set = my_data_set
        
        # X_import, y_import, X, y, X_train, y_train, X_test, y_test  
            # will be set by method handle_input_data() 
            # X: Input array (2D) - at present status of MNIST image data, only.    
            # y: result (=classification data) [digits represent categories in the case of Mnist]
        self._X_import = X_import 
        self._y_import = y_import 
        
        # number of test data 
        self._num_test_records = num_test_records
        
        self._X       = None 
        self._y       = None 
        self._X_train = None 
        self._y_train = None 
        self._X_test  = None   
        self._y_test  = None
        
        # perform a normalization of the input data
        self._b_normalize_X = b_normalize_X
        
        # relevant dimensions 
        # from input data information;  will be set in handle_input_data()
        self._dim_X        = 0  # total num of records in the X,y input sets
        self._dim_sets     = 0  # num of records in the TRAINING sets X_train, y_train
        self._dim_features = 0  
        self._n_labels     = 0   # number of unique labels - will be extracted from y-data 
        
        # Img sizes 
        self._dim_img      = 0 # should be sqrt(dim_features) - we assume square like images  
        self._img_h        = 0 
        self._img_w        = 0 
        
        # Preprocessing of input data 
        # ---------------------------
        self._b_perform_clustering = b_perform_clustering
        self._my_clustering_method = my_clustering_method # for the related dictionary see below 
        self._kmeans        = None   # pointer to object used for clustering  
        self._cl_n_clusters = cl_n_clusters       # number of clusters (often "k" in literature)
        self._cl_max_iter   = cl_max_iter      # number of iterations for centroid movement
        self._cl_n_init     = cl_n_init        # number of different initial centroid positions tried 
        self._cl_batch_size = cl_batch_size    # batch size used for MiniBatchKMeans
        self._cl_n_jobs     = cl_n_jobs        # number of parallel jobs (on CPU-cores) - only used for KMeans
        
        # Layers
        # ------
        # number of hidden layers 
        self._n_hidden_layers = n_hidden_layers
        # Number of total layers 
        self._n_total_layers = 2 + self._n_hidden_layers  
        # Nodes for hidden layers 
        
self._ay_nodes_layers = np.array(ay_nodes_layers)
        # Number of nodes in output layer - will be checked against information from target arrays
        self._n_nodes_layer_out = n_nodes_layer_out
        
        # Weights 
        # --------
        # empty List for all weight-matrices for all layer-connections
        # Numbering : 
        # w[0] contains the weight matrix which connects layer 0 (input layer ) to hidden layer 1 
        # w[1] contains the weight matrix which connects layer 1 (input layer ) to (hidden?) layer 2 
        self._li_w = []
        
        # Arrays for encoded output labels - will be set in _encode_all_mnist_labels()
        # -------------------------------
        self._ay_onehot = None
        self._ay_oneval = None
        
        # Known Randomizer methods ( 0: np.random.randint, 1: np.random.uniform )  
        # ------------------
        self.__ay_known_randomizers = [0, 1]

        # Types of activation functions and output functions 
        # ------------------
        self.__ay_activation_functions = ["sigmoid"] # later also relu 
        self.__ay_output_functions     = ["sigmoid"] # later also softmax 
        
        # Types of cost functions 
        # ------------------
        self.__ay_loss_functions = ["LogLoss", "MSE" ] # later also other types of cost/loss functions  


        # dictionaries for indirect function calls 
        self.__d_activation_funcs = {
            'sigmoid': self._sigmoid, 
            'relu':    self._relu
            }
        self.__d_output_funcs = { 
            'sigmoid': self._sigmoid, 
            'softmax': self._softmax
            }  
        self.__d_loss_funcs = { 
            'LogLoss': self._loss_LogLoss, 
            'MSE': self._loss_MSE
            }  
        # Derivative functions 
        self.__d_D_activation_funcs = {
            'sigmoid': self._D_sigmoid, 
            'relu':    self._D_relu
            }
        self.__d_D_output_funcs = { 
            'sigmoid': self._D_sigmoid, 
            'softmax': self._D_softmax
            }  
        self.__d_D_loss_funcs = { 
            'LogLoss': self._D_loss_LogLoss, 
            'MSE': self._D_loss_MSE
            }  
        self.__d_clustering_functions = {
            'MiniBatchKMeans': self._Mini_Batch_KMeans, 
            'KMeans': self._KMeans
            } 
        
        # The following variables will later be set by _check_and set_activation_and_out_functions()            
        self._my_act_func  = my_activation_function
        self._my_out_func  = my_out_function
        self._my_loss_func = my_loss_function
        self._act_func      = None    
        self._out_func      = None    
        self._loss_func     = None    
        self._cluster_func  = None    
        
        # number of data samples in a mini-batch 
        self._n_size_mini_batch = n_size_mini_batch
        self._n_mini_batches = None  # will be determined by _get_number_of_mini_batches()

        # maximum number of epochs - we set this number to an assumed maximum 
        # - as we shall build a backup and reload functionality for training, this should not be a major problem 
        self._n_epochs = n_epochs
        
        # maximum number of batches to handle ( if < 0 => all!) 
        self._n_max_batches = n_max_batches
        # actual number of batches 
        self._n_batches = None

        # regularization parameters
        self._lambda2_reg = lambda2_reg
        self._lambda1_reg = lambda1_reg
        
        # parameters to control the initialization of the weights (see _create_WM_Input(), create_WM_Hidden())
        self._init_weight_meth_L0 = init_weight_meth_L0
        self._init_weight_meth_Ln = init_weight_meth_Ln
        self._init_weight_
intervals = init_weight_intervals # list of lists with interval borders
        self._init_weight_fact = init_weight_fact           # extends weight intervals 
        
        
        # parameters for adaption of the learning rate
        self._learn_rate = learn_rate
        self._decrease_const = decrease_const
        self._learn_rate_limit = learn_rate_limit
        self._adapt_with_acc  = adapt_with_acc
        self._reduction_fact  = reduction_fact
        #
        # parameters for momentum learning 
        self._mom_rate   = mom_rate
        self._li_mom = [None] *  self._n_total_layers
        
        # shuffle data in X_train? 
        self._b_shuffle_batches = b_shuffle_batches
        
        # perform predictions on train and test data set and related analysis 
        self._b_predictions_train = b_predictions_train
        self._b_predictions_test  = b_predictions_test
        self._prediction_test_period  = prediction_test_period
        self._prediction_train_period = prediction_train_period
        
        # epoch period for printing 
        self._print_period = print_period
        
        # book-keeping for epochs and mini-batches 
        # -------------------------------
        # range for epochs - will be set by _prepare-epochs_and_batches() 
        self._rg_idx_epochs = None
        # range for mini-batches 
        self._rg_idx_batches = None
        # dimension of the numpy arrays for book-keeping - will be set in _prepare_epochs_and_batches() 
        self._shape_epochs_batches = None    # (n_epochs, n_batches, 1) 

        # training evolution:
        # +++++++++++++++++++ 
        # List for error values at outermost layer for minibatches and epochs during training
        # we use a numpy array here because we can redimension it
        self._ay_theta = None
        # List for cost values of mini-batches during training - The list will later be split into sections for epochs 
        self._ay_costs = None
        #
        # List for test accuracy values and error values at epoch periods 
        self._ay_period_test_epoch = None # x-axis for plots of the following 2 quantities 
        self._ay_acc_test_epoch = None  
        self._ay_err_test_epoch = None  
        # List for train accuracy values and error values at epoch periods  
        self._ay_period_train_epoch = None # x-axis for plots of the following 2 quantities 
        self._ay_acc_train_epoch = None  
        self._ay_err_train_epoch = None  
        
        # Data elements for back propagation
        # ----------------------------------
        
        # 2-dim array of partial derivatives of the elements of an additive cost function 
        # The derivative is taken with respect to the output results a_j = ay_ANN_out[j]
        # The array dimensions account for nodes and sampls of a mini_batch. The array will be set in function 
        # self._initiate_bw_propagation()
        self._ay_delta_out_batch = None
        

        # parameter to allow printing of some test data 
        self._b_print_test_data = b_print_test_data

        # Plot handling 
        # --------------
        # Alternatives to resize plots 
        # 1: just resize figure  2: resize plus create subplots() [figure + axes] 
        self._plot_resize_alternative = 1 
        # Plot-sizing
        self._figs_x1 = figs_x1
        self._figs_x2 = figs_x2
        self._fig = None
        self._ax  = None 
        # alternative 2 does resizing and (!) subplots() 
        self.initiate_and_resize_plot(self._plot_resize_alternative)        
        
        
        # ***********
        # operations 
        # ***********
        
        # check and handle input data 
        self._handle_input_data()
        # set the ANN structure 
        self._set_ANN_structure()
        
     
   # Prepare epoch and batch-handling - sets ranges, limits num of mini-batches and initializes book-keeping arrays
        self._rg_idx_epochs, self._rg_idx_batches = self._prepare_epochs_and_batches()

    ''' -- Main Method to prepare epochs, batches and book-keeping arrays -- '''
    def _prepare_epochs_and_batches(self, b_print = True):
        # range of epochs
        ay_idx_epochs  = range(0, self._n_epochs)
        
        # set number of mini-batches and array with indices of input data sets belonging to a batch 
        self._set_mini_batches()
        
        # limit the number of mini-batches
        self._n_batches = min(self._n_max_batches, self._n_mini_batches)
        ay_idx_batches = range(0, self._n_batches)
        if (b_print):
            if  self._n_batches < self._n_mini_batches :
                print("\nWARNING: The number of batches has been limited from " + 
                      str(self._n_mini_batches) + " to " + str(self._n_max_batches) )
        
        # Set the book-keeping arrays 
        self._shape_epochs_batches = (self._n_epochs, self._n_batches)
        self._ay_theta = -1 * np.ones(self._shape_epochs_batches) # float64 numbers as default
        self._ay_costs = -1 * np.ones(self._shape_epochs_batches) # float64 numbers as default
        
        shape_test_epochs  = ( floor(self._n_epochs / self._prediction_test_period), )
        shape_train_epochs = ( floor(self._n_epochs / self._prediction_train_period), )
        self._ay_period_test_epoch  = -1 * np.ones(shape_test_epochs) # float64 numbers as default
        self._ay_acc_test_epoch     = -1 * np.ones(shape_test_epochs) # float64 numbers as default
        self._ay_err_test_epoch     = -1 * np.ones(shape_test_epochs) # float64 numbers as default
        self._ay_period_train_epoch = -1 * np.ones(shape_train_epochs) # float64 numbers as default
        self._ay_acc_train_epoch    = -1 * np.ones(shape_train_epochs) # float64 numbers as default
        self._ay_err_train_epoch    = -1 * np.ones(shape_train_epochs) # float64 numbers as default
        
        return ay_idx_epochs, ay_idx_batches 
#

    ''' Method to predict values for the full set of test data '''
    def _predict_all_test_data(self): 
        size_set = self._X_test.shape[0]
    
        li_Z_in_layer_test  = [None] * self._n_total_layers
        li_Z_in_layer_test[0] = self._X_test
        
        # Transpose input data matrix  
        ay_Z_in_0T       = li_Z_in_layer_test[0].T
        li_Z_in_layer_test[0] = ay_Z_in_0T
        li_A_out_layer_test  = [None] * self._n_total_layers
    
        # prediction by forward propagation of the whole test set 
        self._fw_propagation(li_Z_in = li_Z_in_layer_test, li_A_out = li_A_out_layer_test, b_print = False) 
        ay_predictions_test = np.argmax(li_A_out_layer_test[self._n_total_layers-1], axis=0)
        
        # accuracy 
        ay_errors_test = self._y_test - ay_predictions_test 
        acc_test = (np.sum(ay_errors_test == 0)) / size_set
        # print ("total acc for test data = ", acc)
        # return acc, ay_predictions_test
        return acc_test
#
    ''' Method to predict values for the full set of training data '''
    def _predict_all_train_data(self): 
        size_set = self._X_train.shape[0]
    
        li_Z_in_layer_train  = [None] * self._n_total_layers
        li_Z_in_layer_train[0] = self._X_train
        # Transpose 
        ay_Z_in_0T       = li_Z_in_layer_train[0].T
        li_Z_in_layer_train[0] = ay_Z_in_0T
        li_A_out_layer_train  = [None] * self._n_total_layers
    
        self._fw_propagation(li_Z_in = li_Z_in_layer_train, li_A_out = li_A_out_layer_train, b_print = False) 
        ay_predictions_train = np.argmax(li_A_out_layer_train[self._n_total_layers-1], axis=0)
        ay_errors_train = self._y_train - ay_predictions_train 
        acc_train = (np.sum(ay_errors_train == 0)) / size_set
        #print ("total acc for train data = ", acc)    
        
        return acc_train
#

    ''' -- Method to perform training in epochs for defined mini-batches -- '''
    def _fit(self, b_print = False, b_measure_epoch_time = True, b_measure_batch_time = False):
        '''
        Parameters: 
            b_print:                 Do we print intermediate results of the training at all? 
            b_print_period:          For which period of epochs do we print? 
            b_measure_epoch_time:    Measure CPU-Time for an epoch
            b_measure_batch_time:    Measure CPU-Time for a batch
        '''
        rg_idx_epochs  = self._rg_idx_epochs 
        rg_idx_batches = self._rg_idx_batches
        if (b_print):    
            print("\nnumber of epochs = " + str(len(rg_idx_epochs)))
            print("max number of batches = " + str(len(rg_idx_batches)))
        
        # Some intial parameters 
        acc_old = 0.0000001
        acc_test = 0.001
        orig_rate = self._learn_rate
        adapt_fact = 1.0
        n_predict_test  = 0
        n_predict_train = 0
        
        # loop over epochs
        # ****************
        start_train = time.perf_counter()
        for idxe in rg_idx_epochs:
            if b_print and (idxe % self._print_period == 0):
                if b_measure_epoch_time:
          
          start_0_e = time.perf_counter()
                print("\n ---------")
                print("Starting epoch " + str(idxe+1))
            
            # simple adaption of the learning rate 
            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            orig_rate /= (1.0 + self._decrease_const * idxe)
            self._learn_rate /= (1.0 + self._decrease_const * idxe)
            if self._learn_rate < self._learn_rate_limit:
                self._learn_rate = self._learn_rate_limit
            
            # adapt wit acc. - not working well, yet 
            #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            acc_change_rate = math.fabs((acc_test - acc_old) / acc_old)
            if b_print and (idxe % self._print_period == 0):
                print("acc_chg_rate = ", acc_change_rate)
            ratio = self._learn_rate / orig_rate 
            if ratio > 0.33 and acc_change_rate < 1/3 and self._adapt_with_acc:
                if acc_change_rate < 0.001:
                    acc_change_rate = 0.001
                #adapt_fact = 2.0 * acc_change_rate / (1.0 - acc_change_rate)
                adapt_fact = 1.0 - 0.001 * (1.0 - acc_change_rate / (1.0 - acc_change_rate))
                if b_print and (idxe % self._print_period == 0):
                    print("adapt_fact = ", adapt_fact)
                self._learn_rate *= adapt_fact
            acc_old = acc_test # for adaption of learning rate 
            
            # shuffle indices for a variation of the mini-batches with each epoch
            # ******************************************************************
            if self._b_shuffle_batches:
                shuffled_index = np.random.permutation(self._dim_sets)
                self._X_train, self._y_train, self._ay_onehot = self._X_train[shuffled_index], self._y_train[shuffled_index], self._ay_onehot[:, shuffled_index]
            #
            # loop over mini-batches
            # **********************
            for idxb in rg_idx_batches:
                if b_measure_batch_time: 
                    start_0_b = time.perf_counter()
                # deal with a mini-batch
                self._handle_mini_batch(num_batch = idxb, num_epoch=idxe, b_print_y_vals = False, b_print = False)
                if b_measure_batch_time: 
                    end_0_b = time.perf_counter()
                    print('Time_CPU for batch ' + str(idxb+1), end_0_b - start_0_b) 
            
            #
            # predictions
            # ***********
            # Control and perform predictions on the full test data set 
            if self._b_predictions_test and idxe % self._prediction_test_period == 0:
                self._ay_period_test_epoch[n_predict_test] = idxe
                acc_test = self._predict_all_test_data()
                self._ay_acc_test_epoch[n_predict_test] = acc_test
                n_predict_test += 1
            # Control and perform predictions on the full training training data set 
            if self._b_predictions_train and idxe % self._prediction_train_period == 0:
                self._ay_period_train_epoch[n_predict_train] = idxe
                acc_train = self._predict_all_train_data()
                self._ay_acc_train_epoch[n_predict_train] = acc_train
                n_predict_train += 1
            #
            # printing some evolution and epoch information
            if b_print and (idxe % self._print_period == 0):
                if b_measure_epoch_time:
                    end_0_e = time.perf_counter()
                    print('Time_CPU for epoch' + str(idxe+1), end_0_e - start_0_e) 
                print("learning rate = ", self._learn_rate)
                print("orig learn rate = ", orig_rate)
                print("\ntotal costs of last mini_batch = ", self._ay_costs[idxe, idxb])
                print("avg total error of 
last mini_batch = ", self._ay_theta[idxe, idxb])
                # print presently reached accuracy values on the test and training sets 
                print("presently reached train accuracy =<div style="width: 95%; overflow: auto; height: 400px;">
<pre style="width: 1000px;">
 ", acc_train)
                print("presently reached test accuracy = ", acc_test)
                
        # print out required secs for training
        # **************************************
        end_train = time.perf_counter()
        print('\n\n ------') 
        print('Total training Time_CPU: ', end_train - start_train) 
        print("\nStopping program regularily")

        return None
#

    '''-- Method to create the weight matrix between L0/L1 --'''
    def _create_WM_Input(self):
        '''
        Method to create the input layer 
        The dimension will be taken from the structure of the input data 
        We need to fill self._w[0] with a matrix for conections of all nodes in L0 with all nodes in L1
        We fill the matrix with random numbers between [-1, 1] 
        '''
        # the num_nodes of layer 0 should already include the bias node 
        num_nodes_layer_0 = self._ay_nodes_layers[0]
        num_nodes_with_bias_layer_0 = num_nodes_layer_0 + 1 
        num_nodes_layer_1 = self._ay_nodes_layers[1] 
        
        # Set interval borders for randomizer 
        if self._init_weight_meth_L0 == "sqrt_nodes":  # sqrtr(nodes) - rule of Prof. J. Frochte
            rand_high = self._init_weight_fact / math.sqrt(float(num_nodes_layer_0))
            rand_low = - rand_high 
        else: 
            rand_low  = self._init_weight_intervals[0][0]
            rand_high = self._init_weight_intervals[0][1]
        print("\nL0: weight range [" + str(rand_low) + ", " + str(rand_high) + "]" )
        
        # fill the weight matrix at layer L0 with random values 
        randomizer = 1 # method np.random.uniform   
        rand_size = num_nodes_layer_1 * (num_nodes_with_bias_layer_0) 
        w0 = self._create_vector_with_random_values(rand_low, rand_high, rand_size, randomizer)
        w0 = w0.reshape(num_nodes_layer_1, num_nodes_with_bias_layer_0)
        
        # put the weight matrix into array of matrices 
        self._li_w.append(w0)
        print("\nShape of weight matrix between layers 0 and 1 " + str(self._li_w[0].shape))
        
#
    '''-- Method to create the weight-matrices for hidden layers--''' 
    def _create_WM_Hidden(self):
        '''
        Method to create the weights of the hidden layers, i.e. between [L1, L2] and so on ... [L_n, L_out] 
        We fill the matrix with random numbers between [-1, 1] 
        '''
        
        # The "+1" is required due to range properties ! 
        rg_hidden_layers = range(1, self._n_hidden_layers + 1, 1)
        
        # Check parameter input fro weight intervals 
        if self._init_weight_meth_Ln == "const":
            if len(self._init_
weight_intervals) != (self._n_hidden_layers + 1):
                print("\nError: we shall initialize weights with values from intervals, but wrong number of intervals provided!") 
                sys.exit()
        
        for i in rg_hidden_layers: 
            print ("\nCreating weight matrix for layer " + str(i) + " to layer " + str(i+1) )
            
            num_nodes_layer = self._ay_nodes_layers[i] 
            num_nodes_with_bias_layer = num_nodes_layer + 1 

            # Set interval borders for randomizer 
            if self._init_weight_meth_Ln == "sqrt_nodes":  # sqrtr(nodes) - rule of Prof. J. Frochte
                rand_high = self._init_weight_fact / math.sqrt(float(num_nodes_layer))
                rand_low = - rand_high 
            else: 
                rand_low  = self._init_weight_intervals[i][0]
                rand_high = self._init_weight_intervals[i][1]
            print("L" + str(i) + ": weight range [" + str(rand_low) + ", " + str(rand_high) + "]" )
            
            # the number of the next layer is taken without the bias node!
            num_nodes_layer_next = self._ay_nodes_layers[i+1]
            
            # ill the weight matrices at the hidden layer with random values  
            rand_size = num_nodes_layer_next * num_nodes_with_bias_layer   
            randomizer = 1 # np.random.uniform
            w_i_next = self._create_vector_with_random_values(rand_low, rand_high, rand_size, randomizer)   
            w_i_next = w_i_next.reshape(num_nodes_layer_next, num_nodes_with_bias_layer)
            
            # put the weight matrix into our array of matrices 
            self._li_w.append(w_i_next)
            print("Shape of weight matrix between layers " + str(i) + " and " + str(i+1) + " = " + str(self._li_w[i].shape))
#

    ''' -- Method to handle different types of input data sets --''' 
    def _handle_input_data(self):    
        '''
        Method to deal with the input data: 
        - check if we have a known data set ("mnist" so far)
        - reshape as required 
        - analyze dimensions and extract the feature dimension(s) 
        '''
        # check for known dataset 
        try: 
            if (self._my_data_set not in self._input_data_sets ): 
                raise ValueError
        except ValueError:
            print("The requested input data" + self._my_data_set + " is not known!" )
            sys.exit()   
        
        # MNIST datasets 
        # **************
        
        # handle the mnist original dataset - is not supported any more 
        #if ( self._my_data_set == "mnist"): 
        #    mnist = fetch_mldata('MNIST original')
        #    self._X, self._y = mnist["data"], mnist["target"]
        #    print("Input data for dataset " + self._my_data_set + " : \n" + "Original shape of X = " + str(self._X.shape) +
        #      "\n" + "Original shape of y = " + str(self._y.shape))
        #
        # handle the mnist_784 dataset 
        if ( self._my_data_set == "mnist_784"): 
            mnist2 = fetch_openml('mnist_784', version=1, cache=True, data_home='~/scikit_learn_data') 
            self._X, self._y = mnist2["data"], mnist2["
target"]
            print ("data fetched")
            # the target categories are given as strings not integers 
            self._y = np.array([int(i) for i in self._y])
            print ("data modified")
            print("Input data for dataset " + self._my_data_set + " : \n" + "Original shape of X = " + str(self._X.shape) +
              "\n" + "Original shape of y = " + str(self._y.shape))
            
        # handle the mnist_keras dataset 
        if ( self._my_data_set == "mnist_keras"): 
            (X_train, y_train), (X_test, y_test) = kmnist.load_data()
            len_train =  X_train.shape[0]
            len_test  =  X_test.shape[0]
            X_train = X_train.reshape(len_train, 28*28) 
            X_test  = X_test.reshape(len_test, 28*28) 
            
            # Concatenation required due to possible later normalization of all data
            self._X = np.concatenate((X_train, X_test), axis=0)
            self._y = np.concatenate((y_train, y_test), axis=0)
            print("Input data for dataset " + self._my_data_set + " : \n" + "Original shape of X = " + str(self._X.shape) +
              "\n" + "Original shape of y = " + str(self._y.shape))
        #
        # common MNIST handling 
        if ( self._my_data_set == "mnist" or self._my_data_set == "mnist_784" or self._my_data_set == "mnist_keras" ): 
            self._common_handling_of_mnist()
        
        # handle IMPORTED datasets 
        # **************************+
        if ( self._my_data_set == "imported"): 
            if (self._X_import is not None) and (self._y_import is not None):
                self._X = self._X_import
                self._y = self._y_import
            else:
                print("Shall handle imported datasets - but they are not defined")
                sysexit() 
        #
        # number of total records in X, y
        # *******************************
        self._dim_X = self._X.shape[0]
         
        # Give control to preprocessing - has to happen before normalizing and splitting 
        # ****************************
        self._preprocess_input_data()
        #
        # Common dataset handling 
        # ************************
        # normalization 
        if self._b_normalize_X: 
            # normalization by sklearn.preprocessing.StandardScaler
            scaler = StandardScaler()
            self._X = scaler.fit_transform(self._X)
        
        # mixing the training indices - MUST happen BEFORE encoding 
        shuffled_index = np.random.permutation(self._dim_X)
        self._X, self._y = self._X[shuffled_index], self._y[shuffled_index]

        # Splitting into training and test datasets 
        if self._num_test_records > 0.25 * self._dim_X:
            print("\nNumber of test records bigger than 25% of available data. Too big, we stop." )
            sysexit()
        else:
            num_sep = self._dim_X - self._num_test_records
            self._X_train, self._X_test, self._y_train, self._y_test = self._X[:num_sep], self._X[num_sep:], self._y[:num_sep], self._y[num_sep:] 
        
        # numbers, dimensions
        self._dim_sets = self._y_train.shape[0]
        self._dim_features = self._X_train.shape[1] 
        print("\nFinal dimensions of training and test datasets of type " + self._my_data_set + 
              " : \n" + "Shape of X_train = " + str(self._X_train.shape) + 
              "\n" + "Shape of y_train = " + str(self._y_train.shape) + 
              "\n" + "Shape of X_test = " + str(self._X_test.shape) + 
              "\n" + "Shape of y_test = " + str(self._y_test.shape) 
              )
        print("\nWe have " + str(self._dim_sets) + " data records for training") 
        print("Feature dimension is " + str(self._dim_features)) 
       
    
    
        # encoding the y-values = categories // MUST happen AFTER encoding 
        self._get_num_labels()
        self._encode_all_y_labels(self._b_print_test_data)
        #
        ''' Remark: Other input data sets can not yet be handled ''' 
        return None
#

'''----------  
    Method to preprocess the input data 
    ----------------------------------- '''
    def _preprocess_input_data(self):
        
        # normalization ahead
        if self._b_normalize_X: 
            # normalization by sklearn.preprocessing.StandardScaler
            scaler = StandardScaler()
            self._X = scaler.fit_transform(self._X)

        # Clustering 
        if self._b_perform_clustering:
            self._perform_clustering()
            print("\nClustering started")
        else:
            print("\nNo Clustering requested")
            
        return None
#