Interfaces.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using MyCaffe.db.image;
using MyCaffe.param;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace MyCaffe.common
{
    public delegate void onSetWorkspace(object sender, WorkspaceArgs e);
    public delegate void onGetWorkspace(object sender, WorkspaceArgs e);
 
    [Serializable]
    public enum WEIGHT_TARGET
    {
        NONE,
        WEIGHTS,
        BIAS,
        BOTH
    }
 
    [Serializable]
    public enum BLOB_TYPE
    {
        UNKNOWN = 0x0000,
        DATA = 0x0001,
        IP_WEIGHT = 0x0002,
        WEIGHT = 0x0004,
        LOSS = 0x0008,
        ACCURACY = 0x0010,
        CLIP = 0x0020,
        MULTIBBOX = 0x0040,
        INTERNAL = 0x0080,
        TARGET = 0x0100,
        PREDICTION = 0x0200,
        ATTENTION = 0x0400
    }
 
    [Serializable]
    [DataContract]
    public enum TRAIN_STEP
    {
        [EnumMember]
        NONE = 0x0000,
        [EnumMember]
        FORWARD = 0x0001,
        [EnumMember]
        BACKWARD = 0x0002,
        [EnumMember]
        BOTH = 0x0003
    }
 
    public interface IXDebugData<T>
    {
        BlobCollection<T> data { get; }
        BlobCollection<T> labels { get; }
        string name { get; }
        long kernel_handle { get; }
        int load_count { get; }
    }
 
    public interface IXPersist<T>
    {
        byte[] SaveWeights(BlobCollection<T> colBlobs, bool bSaveDiffs = false);
 
        BlobCollection<T> LoadWeights(byte[] rgWeights, List<string> rgExpectedShapes, BlobCollection<T> colBlobs, bool bSizeToFit, out bool bLoadedDiffs, List<string> inputWtInfo = null, List<string> targetWtInfo = null, string strSkipBlobType = null);
 
        byte[] SaveSolverState(SolverState state, SolverParameter.SolverType type = SolverParameter.SolverType.SGD);
 
        SolverState LoadSolverState(byte[] rgState, SolverParameter.SolverType type = SolverParameter.SolverType.SGD);
 
        WeightInfo<T> LoadWeightInfo(byte[] rgWeights);
 
        WeightInfo<T> LoadWeightInfo(BlobCollection<T> colBlobs);
    }
 
    public interface IXMyCaffeState<T>
    {
        void SetOnTestOverride(EventHandler<TestArgs> onTest);
 
        void AddCancelOverrideByName(string strEvtCancel);
 
        void AddCancelOverride(CancelEvent evtCancel);
 
        void RemoveCancelOverrideByName(string strEvtCancel);
 
        void RemoveCancelOverride(CancelEvent evtCancel);
 
        bool EnableBlobDebugging { get; set; }
        bool EnableBreakOnFirstNaN { get; set; }
        bool EnableDetailedNanDetection { get; set; }
        bool EnableSingleStep { get; set; }
        bool EnableLayerDebugging { get; set; }
 
        IXPersist<T> Persist { get; }
        IXDatabaseBase Database { get; }
 
        CancelEvent CancelEvent { get; }
        List<int> ActiveGpus { get; }
        string ActiveLabelCounts { get; }
        string LabelQueryHitPercents { get; }
        string LabelQueryEpochs { get; }
        string CurrentDevice { get; }
        ProjectEx CurrentProject { get; }
        int CurrentIteration { get; }
        int MaximumIteration { get; }
        int GetDeviceCount();
        string GetDeviceName(int nDeviceID);
        bool ReInitializeParameters(WEIGHT_TARGET target, params string[] rgstrLayers);
        bool VerifyCompute(string strExtra = null, int nDeviceID = -1, bool bThrowException = true);
    }
 
    public interface IXMyCaffe<T>
    {
        bool Load(Phase phase, ProjectEx p, DB_LABEL_SELECTION_METHOD? labelSelectionOverride = null, DB_ITEM_SELECTION_METHOD? itemSelectionOverride = null, bool bResetFirst = false, IXDatabaseBase db = null, bool bUseDb = true, bool bCreateRunNet = true, string strStage = null, bool bEnableMemTrace = false);
        bool Load(Phase phase, string strSolver, string strModel, byte[] rgWeights, DB_LABEL_SELECTION_METHOD? labelSelectionOverride = null, DB_ITEM_SELECTION_METHOD? itemSelectionOverride = null, bool bResetFirst = false, IXDatabaseBase db = null, bool bUseDb = true, bool bCreateRunNet = true, string strStage = null, bool bEnableMemTrace = false);
        void Unload(bool bUnloadDb = true, bool bIgnoreExceptions = false);
        void Train(int nIterationOverride = -1, int nTrainingTimeLimitInMinutes = 0, TRAIN_STEP step = TRAIN_STEP.NONE, double dfLearningRateOverride = 0, bool bReset = false);
        double Test(int nIterationOverride = -1);
        PropertySet TestMany(PropertySet customInput);
        List<Tuple<SimpleDatum, ResultCollection>> TestMany(int nCount, bool bOnTrainingSet, bool bOnTargetSet = false, DB_ITEM_SELECTION_METHOD imgSelMethod = DB_ITEM_SELECTION_METHOD.RANDOM, int nImageStartIdx = 0, DateTime? dtImageStartTime = null, double? dfThreshold = null);
        ResultCollection Run(int nImageIdx, bool bPad = true);
        List<ResultCollection> Run(List<int> rgImageIdx);
        ResultCollection Run(SimpleDatum d, bool bSort = true, bool bUseSolverNet = false);
        Bitmap GetTestImage(Phase phase, out int nLabel, out string strLabel);
        Bitmap GetTestImage(Phase phase, int nLabel);
        SimpleDatum GetItemMean();
        DatasetDescriptor GetDataset();
        byte[] GetWeights();
        void UpdateRunWeights(bool bOutputStatus = false, bool bVerifyWeights = true);
        void UpdateWeights(byte[] rgWeights);
        string GetLicenseText(string strOtherLicenses);
    }
 
    public interface IXMyCaffeNoDb<T>
    {
        void LoadToRun(string strModel, byte[] rgWeights, BlobShape shape, SimpleDatum sdMean = null, TransformationParameter transParam = null, bool bForceBackward = false, bool bConvertToRunNet = true);
        Blob<T> CreateDataBlob(SimpleDatum d, Blob<T> blob = null, bool bPad = true);
        ResultCollection Run(Bitmap img, bool bSort = true, bool bPad = true);
        ResultCollection Run(SimpleDatum d, bool bSort = true, bool bPad = true);
    }
 
    public interface IXMyCaffeExtension<T>
    {
        long CreateExtension(string strExtensionDLLPath);
        void FreeExtension(long hExtension);
        T[] RunExtension(long hExtension, long lfnIdx,  T[] rgParam);
        double[] RunExtensionD(long hExtension, long lfnIdx, double[] rgParam);
        float[] RunExtensionF(long hExtension, long lfnIdx, float[] rgParam);
    }
}