Interfaces.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
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.Tasks;
 
namespace MyCaffe.gym
{
    public enum GYM_DS_ID
    {
        CARTPOLE = 99990001,
        ATARI = 99990002,
        CURVE = 99990003,
        DATAGENERAL = 99991001,
        MODEL = 99991002
    }
 
    public enum GYM_SRC_TRAIN_ID
    {
        CARTPOLE = 99995001,
        ATARI = 99995002,
        CURVE = 99995003,
        DATAGENERAL = 99996001,
        MODEL = 99996002
    }
 
    public enum GYM_SRC_TEST_ID
    {
        CARTPOLE = 99997001,
        ATARI = 99997002,
        CURVE = 99997003,
        DATAGENERAL = 99998001,
        MODEL = 99998002
    }
 
    public interface IXMyCaffeGym
    {
        void Initialize(Log log, PropertySet properties);
        void Close();
        IXMyCaffeGym Clone(PropertySet properties = null);
        string Name { get; }
        Tuple<State, double, bool> Reset(bool bGetLabel = false, PropertySet props = null);
        Tuple<State, double, bool> Step(int nAction, bool bGetLabel = false, PropertySet extraProp = null);
        Tuple<Bitmap, SimpleDatum> Render(bool bShowUi, int nWidth, int nHeight, bool bGetAction);
        Tuple<Bitmap, SimpleDatum> Render(bool bShowUi, int nWidth, int nHeight, double[] rgData, bool bGetAction);
        Dictionary<string, int> GetActionSpace();
        DatasetDescriptor GetDataset(DATA_TYPE dt, Log log = null);
        int UiDelay { get; }
        DATA_TYPE SelectedDataType { get; }
        DATA_TYPE[] SupportedDataType { get; }
        bool RequiresDisplayImage { get; }
        double TestingPercent { get; }
    }
 
    public interface IXMyCaffeGymData : IXMyCaffeGym
    {
        byte[] ConvertOutput(Stage stage, int nN, float[] rg, out string type);
        Phase ActivePhase { get; set; }
    }
 
    public interface IXMyCaffeGymRange : IXMyCaffeGym
    {
        Tuple<double, double> GetDataRange();
        bool UseFixedVocabulary { get; }
        int VocabularySize { get; }
        bool UsePreLoadData { get; }
    }
 
    public class DataPoint
    {
        float[] m_rgfInputs;
        float[] m_rgfMask;
        float m_fTarget;
        float m_fTime;
        List<double> m_rgdfPredicted = null;
        List<string> m_rgstrPredicted = null;
        List<bool> m_rgbEmphasize = null;
 
        public DataPoint(float[] rgfInputs, float[] rgfMask, float fTarget, List<double> rgdfPredicted, List<string> rgstrPredicted, List<bool> rgbEmphasize, float fTime)
        {
            m_rgfInputs = rgfInputs;
            m_rgfMask = rgfMask;
            m_fTarget = fTarget;
            m_fTime = fTime;
 
            m_rgdfPredicted = rgdfPredicted;
            m_rgstrPredicted = rgstrPredicted;
            m_rgbEmphasize = rgbEmphasize;
        }
 
        public float[] Inputs
        {
            get { return m_rgfInputs; }
        }
 
        public float[] Mask
        {
            get { return m_rgfMask; }
        }
 
        public float Target
        {
            get { return m_fTarget; }
        }
 
        public List<double> Predicted
        {
            get { return m_rgdfPredicted; }
        }
 
        public List<string> PredictedLabels
        {
            get { return m_rgstrPredicted; }
        }
 
        public List<bool> PredictedEmphasize
        {
            get { return m_rgbEmphasize; }
        }
 
        public float Time
        {
            get { return m_fTime; }
        }
 
        public DataPoint Clone()
        {
            return new DataPoint(m_rgfInputs, m_rgfMask, m_fTarget, Utility.Clone<double>(m_rgdfPredicted), Utility.Clone<string>(m_rgstrPredicted), Utility.Clone<bool>(m_rgbEmphasize), m_fTime);
        }
    }
 
    public abstract class State
    {
        protected List<DataPoint> m_rgPrevPoints = new List<DataPoint>();
 
        public State()
        {
        }
        public abstract State Clone();
        public abstract SimpleDatum GetData(bool bNormalize, out int nDataLen);
        public virtual bool HasClip { get { return false; } }
        public virtual SimpleDatum GetClip() { throw new NotImplementedException(); }
        public virtual bool HasLabel {  get { return false; } }
        public virtual SimpleDatum GetLabel() { throw new NotImplementedException(); }
 
        public List<DataPoint> History
        {
            get { return m_rgPrevPoints; }
        }
    }
}