EventArgs.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.param;
using MyCaffe.basecode;
 
namespace MyCaffe.common
{
    public class WorkspaceArgs : EventArgs
    {
        ulong m_lWorkspaceSize = 0;
        long m_hWorkspaceData = 0;  // underlying storage.
 
        public WorkspaceArgs(long hData, ulong lSize)
        {
            m_hWorkspaceData = hData;
            m_lWorkspaceSize = lSize;
        }
 
        public long WorkspaceData
        {
            get { return m_hWorkspaceData; }
            set { m_hWorkspaceData = value; }
        }
 
        public ulong WorkspaceSizeInBytes
        {
            get { return m_lWorkspaceSize; }
            set { m_lWorkspaceSize = value; }
        }
    }
 
    public class GetConversionBlobArgs<T> : EventArgs
    {
        Blob<T> m_blobBaseWork;
        Blob<T> m_blobHalfWork;
 
        public GetConversionBlobArgs()
        {
        }
 
        public Blob<T> BaseWork
        {
            get { return m_blobBaseWork; }
            set { m_blobBaseWork = value; }
        }
 
        public Blob<T> HalfWork
        {
            get { return m_blobHalfWork; }
            set { m_blobHalfWork = value; }
        }
    }
 
    public class GetWorkBlobArgs<T> : EventArgs
    {
        Blob<T> m_work = null;
 
        public GetWorkBlobArgs()
        {
        }
 
        public Blob<T> Blob
        {
            get { return m_work; }
            set { m_work = value; }
        }
    }
 
    public class TestResultArgs<T> : EventArgs
    {
        BlobCollection<T> m_results;
        double m_dfAccuracy;
        bool m_bAccuracyValid = false;
 
        public TestResultArgs(BlobCollection<T> res)
        {
            m_results = res;
            m_dfAccuracy = 0;
        }
 
        public BlobCollection<T> Results
        {
            get { return m_results; }
        }
 
        public double Accuracy
        {
            get { return m_dfAccuracy; }
            set 
            { 
                m_dfAccuracy = value;
                m_bAccuracyValid = true;
            }
        }
 
        public bool AccuracyValid
        {
            get { return m_bAccuracyValid; }
            set { m_bAccuracyValid = value; }
        }
    }
 
    public class TestArgs : EventArgs
    {
        int m_nIterationOverride = -1;
        int m_nTestNetID = 0;
        double m_dfAccuracy = 0;
        
        public TestArgs(int nIterationOverride, int nTestNetID)
        {
            m_nIterationOverride = nIterationOverride;
            m_nTestNetID = nTestNetID;
        }
 
        public int IterationOverride
        {
            get { return m_nIterationOverride; }
        }
 
        public int TestNetID
        {
            get { return m_nTestNetID; }
        }
 
        public double Accuracy
        {
            get { return m_dfAccuracy; }
            set { m_dfAccuracy = value; }
        }
    }
 
    public class TestingIterationArgs<T> : EventArgs
    {
        double m_dfAccuracy;
        int m_nIteration;
        double m_dfMsTiming = 0;
 
        public TestingIterationArgs(int nIteration, double dfAccuracy, double dfMsTiming)
        {
            m_dfAccuracy = dfAccuracy;
            m_nIteration = nIteration;
            m_dfMsTiming = dfMsTiming;
        }
 
        public double Accuracy
        {
            get { return m_dfAccuracy; }
        }
 
        public int Iteration
        {
            get { return m_nIteration; }
        }
 
        public double Timing
        {
            get { return m_dfMsTiming; }
        }
    }
 
    public class TrainingIterationArgs<T> : TestingIterationArgs<T>
    {
        double m_dfLoss;
        double m_dfSmoothedLoss;
        double m_dfBestSmoothedLoss;
        bool m_bWeightsUpdated = false;
        string m_strActiveLabelCounts = "";
        string m_strLabelQueryHitPercents = "";
        string m_strLabelQueryEpochs = "";
        string m_strBoostQueryHitPercents = "";
        double m_dfLearningRate = 0;
        DebugInformation<T> m_dbgInfo = null;
 
        public TrainingIterationArgs(int nIteration, double dfAccuracy, double dfLoss, double dfSmoothedLoss, double dfBestSmoothedLoss, bool bWeightsUpdated, string strActiveLabelCounts, string strLabelQueryHitPercents, string strLabelQueryEpochs, string strBoostQueryHitPercents, double dfLearningRate, double dfMsTiming, DebugInformation<T> dbgInfo = null)
            : base(nIteration, dfAccuracy, dfMsTiming)
        {
            m_dfLoss = dfLoss;
            m_dfSmoothedLoss = dfSmoothedLoss;
            m_dfBestSmoothedLoss = dfBestSmoothedLoss;
            m_bWeightsUpdated = bWeightsUpdated;
            m_strActiveLabelCounts = strActiveLabelCounts;
            m_strLabelQueryHitPercents = strLabelQueryHitPercents;
            m_strLabelQueryEpochs = strLabelQueryEpochs;
            m_strBoostQueryHitPercents = strBoostQueryHitPercents;
            m_dfLearningRate = dfLearningRate;
            m_dbgInfo = dbgInfo;
        }
 
        public double Loss
        {
            get { return m_dfLoss; }
        }
 
        public double SmoothedLoss
        {
            get { return m_dfSmoothedLoss; }
        }
 
        public double BestSmoothedLoss
        {
            get { return m_dfBestSmoothedLoss; }
        }
 
        public bool WeightsUpdated
        {
            get { return m_bWeightsUpdated; }
        }
 
        public string ActiveLabelCounts
        {
            get { return m_strActiveLabelCounts; }
        }
 
        public string LabelQueryHitPercents
        {
            get { return m_strLabelQueryHitPercents; }
        }
 
        public string LabelQueryEpochs
        {
            get { return m_strLabelQueryEpochs; }
        }
 
        public string BoostQueryHitPercents
        {
            get { return m_strBoostQueryHitPercents; }
        }
 
        public double LearningRate
        {
            get { return m_dfLearningRate; }
        }
 
        public DebugInformation<T> DebugInformation
        {
            get { return m_dbgInfo; }
        }
    }
 
    public class GetBytesArgs : EventArgs
    {
        byte[] m_rgBytes = null;
 
        public GetBytesArgs()
        {
        }
 
        public byte[] Data
        {
            get { return m_rgBytes; }
            set { m_rgBytes = value; }
        }
    }
 
    public class SnapshotArgs : EventArgs
    {
        byte[] m_rgWeights = null;
        byte[] m_rgState = null;
        double m_dfAccuracy = 0;
        double m_dfError = 0;
        int m_nIteration = 0;
        SNAPSHOT_WEIGHT_UPDATE_METHOD m_favor = SNAPSHOT_WEIGHT_UPDATE_METHOD.FAVOR_ACCURACY;
        bool m_bIncludeWeights = true;
        bool m_bIncludeState = false;
        bool m_bSingleStep = false;
        bool m_bForced = false;
        bool m_bScheduled = true;
        bool m_bUpdateDatabase = true;
 
 
        public event EventHandler<GetBytesArgs> OnGetWeights;
        public event EventHandler<GetBytesArgs> OnGetState;
 
        public SnapshotArgs(byte[] rgState, byte[] rgWeights, double dfAccuracy, double dfError, int nIteration, SNAPSHOT_WEIGHT_UPDATE_METHOD favor)
        {
            m_rgState = rgState;
            m_rgWeights = rgWeights;
            m_dfAccuracy = dfAccuracy;
            m_dfError = dfError;
            m_nIteration = nIteration;
            m_favor = favor;
        }
 
        public byte[] UpdateState()
        {
            if (OnGetState != null)
            {
                GetBytesArgs args = new common.GetBytesArgs();
                OnGetState(this, args);
                m_rgState = args.Data;
                return m_rgState;
            }
 
            return null;
        }
 
        public byte[] UpdateWeights()
        {
            if (OnGetWeights != null)
            {
                GetBytesArgs args = new common.GetBytesArgs();
                OnGetWeights(this, args);
                m_rgWeights = args.Data;
                return m_rgWeights;
            }
 
            return null;
        }
 
        public byte[] State
        {
            get { return m_rgState; }
            set { m_rgState = value; }
        }
 
        public byte[] Weights
        {
            get { return m_rgWeights; }
            set { m_rgWeights = value; }
        }
 
        public double Accuracy
        {
            get { return m_dfAccuracy; }
        }
 
        public double Error
        {
            get { return m_dfError; }
        }
 
        public int Iteration
        {
            get { return m_nIteration; }
        }
 
        public SNAPSHOT_WEIGHT_UPDATE_METHOD Favor
        {
            get { return m_favor; }
        }
 
        public bool IncludeWeights
        {
            get { return m_bIncludeWeights; }
            set { m_bIncludeWeights = value; }
        }
 
        public bool IncludeState
        {
            get { return m_bIncludeState; }
            set { m_bIncludeState = value; }
        }
 
        public bool SingleStep
        {
            get { return m_bSingleStep; }
            set { m_bSingleStep = value; }
        }
 
        public bool Forced
        {
            get { return m_bForced; }
            set { m_bForced = value; }
        }
 
        public bool Scheduled
        {
            get { return m_bScheduled; }
            set { m_bScheduled = value; }
        }
 
        public bool UpdateDatabase
        {
            get { return m_bUpdateDatabase; }
            set { m_bUpdateDatabase = value; }
        }
    }
 
    public class CustomForwardBackArgs<T> : EventArgs
    {
        Net<T> m_net;
        TRAIN_STEP m_step;
        bool m_bFwdPassNanFree = true;
        double m_dfLocalLoss = 0;
 
        public CustomForwardBackArgs(Net<T> net, TRAIN_STEP step)
        {
            m_net = net;
            m_step = step;
        }
 
        public Net<T> net
        {
            get { return m_net; }
        }
 
        public TRAIN_STEP step
        {
            get { return m_step; }
        }
 
        public bool FwdPassNanFree
        {
            get { return m_bFwdPassNanFree; }
            set { m_bFwdPassNanFree = value; }
        }
 
        public double LocalLoss
        {
            get { return m_dfLocalLoss; }
            set { m_dfLocalLoss = value; }
        }
    }
 
    public class ForwardArgs<T>
    {
        BlobCollection<T> m_colTop;
        BlobCollection<T> m_colBottom;
 
        public ForwardArgs(BlobCollection<T> colBottom, BlobCollection<T> colTop)
        {
            m_colTop = colTop;
            m_colBottom = colBottom;
        }
 
        public BlobCollection<T> BottomVec
        {
            get { return m_colBottom;  }
        }
 
        public BlobCollection<T> TopVec
        {
            get { return m_colTop; }
        }
    }
 
    public class BackwardArgs<T> : ForwardArgs<T>
    {
        List<bool> m_rgbPropagateDown;
 
        public BackwardArgs(BlobCollection<T> colTop, List<bool> rgbPropagateDown, BlobCollection<T> colBottom)
            : base(colBottom, colTop)
        {
            m_rgbPropagateDown = rgbPropagateDown;
        }
 
        public List<bool> PropagateDown
        {
            get { return m_rgbPropagateDown; }
        }
    }
 
    public class GradientsReadyArgs : EventArgs 
    {
        public GradientsReadyArgs()
        {
        }
    }
 
    public class GetIterationArgs : EventArgs
    {
        int m_nIteration = 0;
        Phase m_phase = Phase.TRAIN;
 
        public GetIterationArgs()
        {
        }
 
        public void SetIteration(Phase p, int nIteration)
        {
            m_phase = p;
            m_nIteration = nIteration;
        }
 
        public int Iteration
        {
            get { return m_nIteration; }
        }
 
        public Phase CurrentPhase
        {
            get { return m_phase; }
        }
    }
}