QueryState.cs

using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace MyCaffe.db.image
{
    public class QueryState : MasterIndexes
    {
        MasterIndexes m_master;
        LabelStats m_stat;
        bool m_bUseUniqueImageIndexes = true;
        bool m_bUseUniqueLabelIndexes = true;
 
        public QueryState(MasterIndexes master, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.BYIDX) : base(master, sort)
        {
            m_master = master;
            m_stat = new LabelStats(master.LabelCount);
            m_bUseUniqueLabelIndexes = bUseUniqueLabelIndexes;
            m_bUseUniqueImageIndexes = bUseUniqueImageIndexes;
 
            foreach (LabelDescriptor label in m_src.Labels)
            {
                m_stat.Add(label);
            }
        }
 
        public void UpdateStats(SimpleDatum sd)
        {
            m_stat.UpdateLabel(sd.Label);
            m_stat.UpdateBoost(sd.Boost);
        }
 
        public int? GetNextLabel(DB_LABEL_SELECTION_METHOD lblSel)
        {
            Index.SELECTION_TYPE selType = Index.SELECTION_TYPE.RANDOM;
            bool bBoost = false;
 
            if ((lblSel & DB_LABEL_SELECTION_METHOD.RANDOM) != DB_LABEL_SELECTION_METHOD.RANDOM)
                selType = Index.SELECTION_TYPE.SEQUENTIAL;
 
            if ((lblSel & DB_LABEL_SELECTION_METHOD.BOOST) == DB_LABEL_SELECTION_METHOD.BOOST)
                bBoost = true;
 
            return GetNextLabel(selType, bBoost);
        }
 
        public override int? GetNextLabel(Index.SELECTION_TYPE type, bool bBoosted = false)
        {
            LabelIndex rgIdx = (bBoosted) ? m_rgLabelsBoosted : m_rgLabels;
            if (rgIdx.Count == 0)
                return null;
 
            int? nIdx = rgIdx.GetNextLabel(type, null, m_bUseUniqueLabelIndexes);
            if (rgIdx.IsEmpty)
                rgIdx.ReLoad();
 
            return nIdx;
        }
 
        public int? GetNextImage(DB_ITEM_SELECTION_METHOD imgSel, int? nLabel, int nDirectIdx)
        {
            if (!nLabel.HasValue && imgSel == DB_ITEM_SELECTION_METHOD.NONE && nDirectIdx >= 0)
                return GetNextImage(Index.SELECTION_TYPE.DIRECT, null, false, nDirectIdx);
 
            Index.SELECTION_TYPE selType = Index.SELECTION_TYPE.RANDOM;
            bool bBoosted = false;
 
            if ((imgSel & DB_ITEM_SELECTION_METHOD.RANDOM) != DB_ITEM_SELECTION_METHOD.RANDOM)
            {
                selType = Index.SELECTION_TYPE.SEQUENTIAL;
 
                // When using PAIR, advance to the next item.
                if ((imgSel & DB_ITEM_SELECTION_METHOD.PAIR) == DB_ITEM_SELECTION_METHOD.PAIR)
                    GetNextImage(selType, nLabel, bBoosted, -1);
            }
 
            if ((imgSel & DB_ITEM_SELECTION_METHOD.BOOST) == DB_ITEM_SELECTION_METHOD.BOOST)
                bBoosted = true;
 
            return GetNextImage(selType, nLabel, bBoosted, -1);
        }
 
        public override int? GetNextImage(Index.SELECTION_TYPE type, int? nLabel = null, bool bBoosted = false, int nDirectIdx = -1)
        {
            int? nIdx = null;
 
            if (m_master.LoadLimit > 0)
            {
                nIdx = base.GetNextImage(type, nLabel, bBoosted, nDirectIdx);
            }
            else
            {
                Index idx;
                if (type == Index.SELECTION_TYPE.DIRECT)
                {
                    if (nDirectIdx < 0)
                        throw new Exception("Invalid direct index, must be >= 0.");
 
                    idx = GetIndex(null, false);
                    nIdx = idx.GetIndex(nDirectIdx);
                }
                else
                {
                    idx = GetIndex(nLabel, bBoosted);
                    if (idx == null)
                    {
                        SetIndex(m_master.GetIndex(nLabel, bBoosted).Clone(), nLabel, bBoosted);
                        idx = GetIndex(nLabel, bBoosted);
                        nIdx = idx.GetNext(type, m_bUseUniqueImageIndexes);
                    }
                    else
                    {
                        nIdx = idx.GetNext(type, m_bUseUniqueImageIndexes);
                        if (idx.IsEmpty)
                            SetIndex(m_master.GetIndex(nLabel, bBoosted).Clone(), nLabel, bBoosted);
                    }
                }
            }
 
            return nIdx;
        }
 
        public Dictionary<int, ulong> GetQueryLabelCounts()
        {
            return m_stat.GetCounts();
        }
 
        public string GetQueryBoostHitPercentsAsText()
        {
            return m_stat.GetQueryBoostHitPercentsAsText();
        }
 
        public string GetQueryLabelHitPercentsAsText()
        {
            return m_stat.GetQueryLabelHitPercentsAsText();
        }
 
        public string GetQueryLabelEpochsAsText()
        {
            return m_stat.GetQueryLabelEpochAsText();
        }
    }
 
    public class QueryStateCollection : IDisposable
    {
        Dictionary<long, Tuple<QueryState, QueryState>> m_rgQueryStates = new Dictionary<long, Tuple<QueryState, QueryState>>();
        object m_objSync = new object();
 
        public QueryStateCollection()
        {
            // Fill with blank item for first handle, for handle = 0 is not used.
            m_rgQueryStates.Add(0, null); 
        }
 
        public void Dispose()
        {
            foreach (KeyValuePair<long, Tuple<QueryState, QueryState>> kv in m_rgQueryStates)
            {
                kv.Value.Item1.Dispose();
                kv.Value.Item2.Dispose();
            }
 
            m_rgQueryStates.Clear();
        }
 
        public long CreateNewState(QueryState training, QueryState testing)
        {
            long lHandle = 0;
 
            lock (m_objSync)
            {
                if (m_rgQueryStates.Count > 0)
                    lHandle = m_rgQueryStates.Max(p => p.Key) + 1;
 
                m_rgQueryStates.Add(lHandle, new Tuple<QueryState, QueryState>(training, testing));
            }
 
            return lHandle;
        }
 
        public bool FreeQueryState(long lHandle)
        {
            if (lHandle == 0)
                return false;
 
            lock (m_objSync)
            {
                if (m_rgQueryStates.ContainsKey(lHandle))
                {
                    m_rgQueryStates[lHandle].Item1.Dispose();
                    m_rgQueryStates[lHandle].Item2.Dispose();
                    m_rgQueryStates.Remove(lHandle);
                    return true;
                }
 
                return false;
            }
        }
 
        public QueryState GetTrainingState(long lHandle)
        {
            if (lHandle == 0)
                throw new Exception("Invalid training QueryState handle, cannot = 0.");
 
            lock (m_objSync)
            {
                return m_rgQueryStates[lHandle].Item1;
            }
        }
 
        public QueryState GetTestingState(long lHandle)
        {
            if (lHandle == 0)
                throw new Exception("Invalid testing QueryState handle, cannot = 0.");
 
            lock (m_objSync)
            {
                return m_rgQueryStates[lHandle].Item2;
            }
        }
 
        public void ReIndexTraining(List<DbItem> rgItems)
        {
            lock (m_objSync)
            {
                foreach (KeyValuePair<long, Tuple<QueryState, QueryState>> kv in m_rgQueryStates)
                {
                    if (kv.Value != null)
                        kv.Value.Item1.Reload(rgItems);
                }
            }
        }
 
        public void ReIndexTesting(List<DbItem> rgItems)
        {
            lock (m_objSync)
            {
                foreach (KeyValuePair<long, Tuple<QueryState, QueryState>> kv in m_rgQueryStates)
                {
                    if (kv.Value != null)
                        kv.Value.Item2.Reload(rgItems);
                }
            }
        }
    }
}