CscNeuralNetworkBuilderTensorFlow.h

Go to the documentation of this file.

/*
  *CscNeuralNetworkBuilderTensorFlow.h
 *
 * Created on: 24 juillet 2024
 *     Author: Max Lhermitte
 */
 
#ifndef CSCNEURALNETWORKBUILDERTENSORFLOW_H_
#define CSCNEURALNETWORKBUILDERTENSORFLOW_H_
 
#include "ArtificialIntelligence/CscNeuralNetwork.h"
#include "Util/conscience_util.h"
#include "CscCommon.h"
#include "tensorflow/c/c_api.h"
#include "Util/json.h"
#include "ArtificialIntelligence/CscNeuralNetworkPersistenceTensorFlow.h"
 
using namespace conscience_utils::JSON;
 
 
namespace conscience_core::ai::nn {
 
class CSC_DLL_IMPORTEXPORT CscNeuralNetworkBuilderTensorFlow {
public:
    CscNeuralNetworkBuilderTensorFlow(CscNeuralNetwork::TrainingHyperparameters *trainingHypeparametersInit, CscNeuralNetwork::NeuralNetworkHyperparameters *nnHyperparametersInit, float **weightsLoadedFromModelInit = nullptr, float **biasesLoadedFromModelInit = nullptr);
    virtual ~CscNeuralNetworkBuilderTensorFlow();
    
    // public methods
    TF_Graph *getGraph() const;
    TF_Status *getStatus() const;
    TF_Operation *getGraphOperation() const;
    TF_Output *getTrainableVars();
    TF_Output *getPartialDerivatives();
    vector<const char *> &getAssignationsInitNames();
    vector<const char *> &getAssignationsBestValuesNames();
    vector<const char *> &getAssignationsInitAdagradNames();
    vector<const char *> &getAssignationsInitAdadeltaGradientNames();
    vector<const char *> &getAssignationsInitAdadeltaUpdateNames();
    vector<const char *> &getAssignationsInitAdamFirstMomentNames();
    vector<const char *> &getAssignationsInitAdamSecondMomentNames();
    vector<const char *> &getVarNames();
    vector<const char *> &getVarBestValueNames();
    vector<const char *> &getVarAdagradValueNames();
    vector<const char *> &getVarAdadeltaGradientValueNames();
    vector<const char *> &getVarAdadeltaUpdateValueNames();
    vector<const char *> &getVarAdamFirstMomentValueNames();
    vector<const char *> &getVarAdamSecondMomentValueNames();
    vector<const char *> &getUpdateNames();
    
    void setWeightsLoadedFromModel(float **weightsLoadedFromModelUpdate);
    void setBiasesLoadedFromModel(float **biasesLoadedFromModelUpdate);
    
    // Methods for TF_Output list allocations and initialization
    void allocatePartialDerivatives(int nbOperations);
    
    void allocateAndInitializeTrainableVars(int nbOperations);
    void allocateAndInitializeAccumulators(int nbOperations);
    void allocateAndInitializeGradientAccumulators(int nbOperations);
    void allocateAndInitializeUpdateAccumulators(int nbOperations);
    void allocateAndInitializeMFirstMomentEstimateOutputs(int nbOperations);
    void allocateAndInitializeVSecondMomentEstimateOutputs(int nbOperations);
    
    // Methods for layers operations
    void createVariableInGraph(const int64_t *dims, int num_dims, float *data, int num_data, char *name);
    void createConstantVariableAndAssignOperation(const char *namePrefix, const char *variablePrefix, const char *assignPrefix, const char *name, int numDims, const int64_t *dims, int numData, std::vector<const char *> &valueNames, std::vector<const char *> &assignNames, float *constantValue);
    TF_Operation *createOperationFromTwoOperations(TF_Operation *a, TF_Operation *b, const char *operationString, const char *operationName);
    TF_Operation *createOperationFromSingleOperation(TF_Operation *operation, const char *operationString, const char *operationName);
    TF_Operation *createConstOperation(TF_Tensor *tensor, char *name, TF_DataType dataType);
    TF_Operation *createVariableV2Operation(const int64_t *dims, int numDims, const char *name, TF_DataType dataType);
    TF_Operation *createMatriceMultiplicationOperation(TF_Operation *a, TF_Operation *b);
    TF_Operation *createAdditionOperation(TF_Operation *a, TF_Operation *b);
    TF_Operation *createActivationFunctionOperation(TF_Operation *input_op, CscActivationFunction activFuncName, int nbActivationFunctionOperation);
    TF_Operation *createPlaceHolderOperation(int numFeatures, const char *name);
    TF_Operation *createDenseLayerOperation(TF_Operation *input, const char *weightVarName, const char *biasVarName, CscActivationFunction activFuncName, int denseLayerId);
    
    // Methods for create neural network operation
    TF_Operation *createInputLayerOperation(int numFeatures);
    TF_Operation *createDenseLayer(int hiddenLayerId, int nbNeuronsPreviousLayer, int nbNeuronsLayer, TF_Operation *previousLayer, CscActivationFunction fctActivationName,  CscInitializationWeightsStrategy initilizationStrategy,  CscInitializationBiasStrategy initializationBiasStrategy);
    TF_Operation *createOutputLayerOperation(int nbNeuronsPreviousLayer, TF_Operation *previousLayer, CscActivationFunction fctActivationName, CscLossFunction lossFunction,  CscInitializationWeightsStrategy initializationStrategy, CscInitializationBiasStrategy initializationBiasStrategy, bool withCostFunction);
    TF_Operation *createTargetPlaceHoldersOperation();
    void createNeuralNetwork(CscActivationFunction hiddenLayersFunctionActivation, CscActivationFunction outputLayerFunctionActivation, CscLossFunction lossFunction,  CscInitializationWeightsStrategy initilizationStrategy,  CscInitializationBiasStrategy initializationBiasStrategy, bool withCostFunction);
    
    // Loss functions
    TF_Operation *createCostFunctionOperation(TF_Operation *predictions, CscLossFunction lossFunction);
    TF_Operation *createMeanSquaredErrorCostFunctionOperation(TF_Operation *predictions);
    TF_Operation *createMeanAbsoluteErrorCostFunctionOperation(TF_Operation *predictions);
    
    // update operations
    TF_Operation *createUpdateOperation(CscOptimizer optimizer, int nthVariable);
    TF_Operation *createGradientDescentUpdateOperation(TF_Output variable, TF_Output gradient);
    TF_Operation *createAdagradUpdateOperation(TF_Output variable, TF_Output gradient, TF_Output accumulation);
    TF_Operation *createAdadeltaUpdateOperation(TF_Output variable, TF_Output gradient, TF_Output accumGrad, TF_Output accumUpdate);
    TF_Operation *createAdamUpdateOperation(TF_Output variable, TF_Output gradient, TF_Output mFirstMomentEstimate, TF_Output vSecondMomentEstimate);
    void createAllUpdtateOperations(CscOptimizer optimizer);
    
    static int printTensorShapeOfOperationAndReturnNumberNeurons(TF_Graph *graph, const char *operationName);
 
private:
    unique_ptr<CscLogger> loggerBuilder;
    CscNeuralNetwork::TrainingHyperparameters *trainingHyperparameters = nullptr;
    CscNeuralNetwork::NeuralNetworkHyperparameters *neuralNetworkHyperparameters = nullptr;
    
    // Attributes
    TF_Graph *graph = nullptr;
    TF_Status *status = nullptr;
    TF_Operation *graphOperation = nullptr;
    TF_Output *partialDerivatives = nullptr;
    TF_Output *trainableVars = nullptr;
    TF_Output *accumulators = nullptr;
    TF_Output *gradientAccumulators = nullptr;
    TF_Output *updateAccumulators = nullptr;
    TF_Output *mFirstMomentEstimateOutputs = nullptr;
    TF_Output *vSecondMomentEstimateOutputs = nullptr;
    int timeCounter = 0;
    long counterOperations;
    vector<const char *> assignationsInitNames;
    vector<const char *> assignationsBestValuesNames;
    vector<const char *> assignationsInitAdagradNames;
    vector<const char *> assignationsInitAdadeltaGradientNames;
    vector<const char *> assignationsInitAdadeltaUpdateNames;
    vector<const char *> assignationsInitAdamFirstMomentNames;
    vector<const char *> assignationsInitAdamSecondMomentNames;
    vector<const char *> varNames;
    vector<const char *> varBestValueNames;
    vector<const char *> varAdagradValueNames;
    vector<const char *> varAdadeltaGradientValueNames;
    vector<const char *> varAdadeltaUpdateValueNames;
    vector<const char *> varAdamFirstMomentValueNames;
    vector<const char *> varAdamSecondMomentValueNames;
    vector<const char *> updateNames;
    float **weightsLoadedFromModel = nullptr;
    float **biasesLoadedFromModel = nullptr;
    
    // Debug methods
    void printTensor(TF_Tensor *tensor);
    
    // Others methods
    const char *generateUniqueCharArray();
    bool checkStatus(const string methodName);
    template<typename T> TF_Tensor *createScalarTensor(T value);
    void allocateAndInitializeTF_OutputList(TF_Output **listTF_Output, const vector<const char *> &namesTF_Output, int nbOperations);
};
}
 
#endif /* CSCNEURALNETWORKBUILDERTENSORFLOW_H_ */