DataGeneralGym.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using MyCaffe.db.stream;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace MyCaffe.gym
{
    public class DataGeneralGym : IXMyCaffeGymData, IDisposable
    {
        string m_strName = "DataGeneral";
        Log m_log;
        CryptoRandom m_random;
        Dictionary<string, int> m_rgActions = new Dictionary<string, int>();
        DATA_TYPE m_dt = DATA_TYPE.BLOB;
        MyCaffeStreamDatabase m_db;
        Phase m_phase = Phase.NONE;
 
        public DataGeneralGym()
        {
        }
 
        public void Dispose()
        {
        }
 
        public void Initialize(Log log, PropertySet properties)
        {
            m_log = log;
            m_random = new CryptoRandom();
            m_db = new MyCaffeStreamDatabase(m_log);
            m_db.Initialize(QUERY_TYPE.GENERAL, properties.ToString());
            m_db.Reset();
        }
 
        public IXMyCaffeGym Clone(PropertySet properties = null)
        {
            DataGeneralGym gym = new DataGeneralGym();
 
            if (properties != null)
                gym.Initialize(m_log, properties);
 
            return gym;
        }
 
        public bool RequiresDisplayImage
        {
            get { return false; }
        }
 
        public DATA_TYPE SelectedDataType
        {
            get { return m_dt; }
        }
 
        public DATA_TYPE[] SupportedDataType
        {
            get { return new DATA_TYPE[] { DATA_TYPE.BLOB }; }
        }
 
        public string Name
        {
            get { return m_strName; }
        }
 
        public int UiDelay
        {
            get { return 0; }
        }
 
        public double TestingPercent
        {
            get { return 0.2; }
        }
 
        public Dictionary<string, int> GetActionSpace()
        {
            return m_rgActions;
        }
 
        public void Close()
        {
            m_db.Shutdown();
        }
 
        public Tuple<Bitmap, SimpleDatum> Render(bool bShowUi, int nWidth, int nHeight, bool bGetAction)
        {
            List<double> rgData = new List<double>();
            return Render(bShowUi, nWidth, nHeight, rgData.ToArray(), bGetAction);
        }
 
        public Tuple<Bitmap, SimpleDatum> Render(bool bShowUi, int nWidth, int nHeight, double[] rgData, bool bGetAction)
        {
            return null;
        }
 
        public Tuple<State, double, bool> Reset(bool bGetLabel, PropertySet props = null)
        {
            m_db.Reset();
            return Step(-1, bGetLabel);
        }
 
        public Tuple<State, double, bool> Step(int nAction, bool bGetLabel, PropertySet propExtra = null)
        {
            DataState data = new DataState();
 
            SimpleDatum sd = m_db.Query(1000);
            data.SetData(sd);
 
            return new Tuple<State, double, bool>(data, 0, (sd == null) ? true : false);
        }
 
        public DatasetDescriptor GetDataset(DATA_TYPE dt, Log log = null)
        {
            if (dt == DATA_TYPE.DEFAULT)
                dt = DATA_TYPE.BLOB;
 
            if (dt != DATA_TYPE.BLOB)
            {
                if (log == null)
                    log = m_log;
 
                if (log != null)
                    log.WriteLine("WARNING: This gym only supports the BLOB type, the datatype will be changed to BLOB.");
                else
                    throw new Exception("This gym only supports the BLOB type.");
 
                dt = DATA_TYPE.BLOB;
            }
 
            int nC = 1;
            int nH = 1;
            int nW = 0;
 
            SourceDescriptor srcTrain = new SourceDescriptor((int)GYM_DS_ID.DATAGENERAL, Name + ".training", nW, nH, nC, false, false);
            SourceDescriptor srcTest = new SourceDescriptor((int)GYM_SRC_TEST_ID.DATAGENERAL, Name + ".testing", nW, nH, nC, false, false);
            DatasetDescriptor ds = new DatasetDescriptor((int)GYM_SRC_TRAIN_ID.DATAGENERAL, Name, null, null, srcTrain, srcTest, "DataGym", "Data Gym", null, GYM_TYPE.DATA);
 
            m_dt = dt;
 
            return ds;
        }
 
        public byte[] ConvertOutput(Stage stage, int nN, float[] rg, out string type)
        {
            return m_db.ConvertOutput(rg, out type);
        }
 
        public Phase ActivePhase
        {
            get { return m_phase; }
            set { m_phase = value; }
        }
    }
 
    class DataState : State 
    {
        SimpleDatum m_sd = null;
 
        public DataState()
        {
        }
 
        public DataState(DataState s)
        {
            m_sd = s.m_sd;
        }
 
        public override State Clone()
        {
            DataState data = new DataState(this);
            data.SetData(m_sd);
            return data;
        }
 
        public void SetData(SimpleDatum sd)
        {
            m_sd = sd;
        }
 
        public override SimpleDatum GetData(bool bNormalize, out int nDataLen)
        {
            nDataLen = (m_sd == null) ? 0 : m_sd.ItemCount;
            return m_sd;
        }
    }
}