Пример #1
0
        private static string[] ColumnNames(bool withLabel, ModelValue prediction)
        {
            var columns = new List <string>();
            var data    = new ModelDataSet();

            for (int i = 0; i < data.Features(); i++)
            {
                columns.Add(data.Name(i));
            }

            if (withLabel)
            {
                switch (prediction)
                {
                case ModelValue.Action: columns.Add("Action"); break;

                case ModelValue.Angle: columns.Add("FaceAngle"); break;

                case ModelValue.XY: columns.Add("MoveAngle"); break;

                default: throw new Exception("Unknown value for prediction : " + prediction);
                }
            }

            return(columns.ToArray());
        }
Пример #2
0
        public override float Predict(ModelDataSet input)
        {
            if (TrainedModel == null)
            {
                throw new Exception("Must initialize the model before calling");
            }

            lock (TrainedModel)
            {
                // cache for reuse
                if (PredictInput == null)
                {
                    PredictInput = new float[input.Features()];
                }
                for (int i = 0; i < PredictInput.Length; i++)
                {
                    PredictInput[i] = input.Feature(i);
                }

                using (var arr = InputArray.Create <float>(PredictInput))
                {
                    return(TrainedModel.Predict(arr));
                }
            }
        }
Пример #3
0
        public override float Predict(ModelDataSet data)
        {
            if (TrainedModel == null)
            {
                throw new Exception("Must initialize the model before calling");
            }

            lock (TrainedModel)
            {
                var result = PredictFunc.Predict(data);
                return(result.Score);
            }
        }
Пример #4
0
        public bool Predict(ModelDataSet data, out float xdelta, out float ydelta)
        {
            var angle = Predict(data);

            // set course
            float x1, y1;

            Collision.CalculateLineByAngle(0, 0, angle, 1, out x1, out y1, out xdelta, out ydelta);

            // normalize
            var sum = (float)(Math.Abs(xdelta) + Math.Abs(ydelta));

            xdelta = xdelta / sum;
            ydelta = ydelta / sum;

            if (Math.Abs(xdelta) + Math.Abs(ydelta) > 1.0001)
            {
                throw new Exception("Invalid xdelta,ydelta : " + xdelta + "," + ydelta);
            }

            return(true);
        }
Пример #5
0
 public virtual float Predict(ModelDataSet data)
 {
     return(0);
 }
Пример #6
0
 public static int Features(this ModelDataSet data)
 {
     return(26);
 }
Пример #7
0
        public static ModelDataSet AsModelDataSet(this TrainingData data)
        {
            // transform to ModelDataSet and Normalize (0...1)

            var result = new ModelDataSet()
            {
                // core data
                CenterAngle   = Normalize(data.CenterAngle, 360f),
                InZone        = data.InZone ? 1f : 0,
                Health        = Normalize(data.Health, (float)Constants.MaxHealth),
                Shield        = Normalize(data.Shield, (float)Constants.MaxShield),
                Primary       = Normalize(data.Primary),
                PrimaryAmmo   = data.PrimaryAmmo >= Constants.MaxAmmo ? 1 : Normalize((float)data.PrimaryAmmo, (float)Constants.MaxAmmo),
                PrimaryClip   = Normalize(data.Primary, data.PrimaryClip),
                Secondary     = Normalize(data.Secondary),
                SecondaryAmmo = data.SecondaryAmmo >= Constants.MaxAmmo ? 1 : Normalize((float)data.SecondaryAmmo, (float)Constants.MaxAmmo),
                SecondaryClip = Normalize(data.Secondary, data.SecondaryClip),
            };

            // outcome (not normalize)
            result.Action    = (float)data.Action;
            result.FaceAngle = data.Angle;
            result.MoveAngle = Collision.CalculateAngleFromPoint(0, 0, data.Xdelta, data.Ydelta);

            // proximity
            foreach (var elem in data.Proximity)
            {
                switch (elem.Name)
                {
                case "Ammo":
                    result.Angle_1    = Normalize(elem.Angle, 360f);
                    result.Distance_1 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Bandage":
                    result.Angle_2    = Normalize(elem.Angle, 360f);
                    result.Distance_2 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Helmet":
                    result.Angle_3    = Normalize(elem.Angle, 360f);
                    result.Distance_3 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "AK47":
                    result.Angle_4    = Normalize(elem.Angle, 360f);
                    result.Distance_4 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Shotgun":
                    result.Angle_5    = Normalize(elem.Angle, 360f);
                    result.Distance_5 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Pistol":
                    result.Angle_6    = Normalize(elem.Angle, 360f);
                    result.Distance_6 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Obstacle":
                    result.Angle_7    = Normalize(elem.Angle, 360f);
                    result.Distance_7 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                case "Player":
                    result.Angle_8    = Normalize(elem.Angle, 360f);
                    result.Distance_8 = Normalize(elem.Distance, (float)Constants.ProximityViewWidth);
                    break;

                default:
                    throw new Exception("Unknown proximity element type : " + elem.Name);
                }
            }

            return(result);
        }
Пример #8
0
        public static int ComputeHash(this ModelDataSet data)
        {
            var json = data.ToJson();

            return(json.GetHashCode());
        }
Пример #9
0
 public static string ToJson(this ModelDataSet data)
 {
     return(Newtonsoft.Json.JsonConvert.SerializeObject(data));
 }
Пример #10
0
        public static string Name(this ModelDataSet data, int column)
        {
            switch (column)
            {
            case 0: return("CenterAngle");

            case 1: return("InZone");

            case 2: return("Health");

            case 3: return("Shield");

            case 4: return("Primary");

            case 5: return("PrimaryAmmo");

            case 6: return("PrimaryClip");

            case 7: return("Secondary");

            case 8: return("SecondaryAmmo");

            case 9: return("SecondaryClip");

            // ammo
            case 10: return("Angle_1");

            case 11: return("Distance_1");

            // bandage
            case 12: return("Angle_2");

            case 13: return("Distance_2");

            // helmet
            case 14: return("Angle_3");

            case 15: return("Distance_3");

            // ak47
            case 16: return("Angle_4");

            case 17: return("Distance_4");

            // shotgun
            case 18: return("Angle_5");

            case 19: return("Distance_5");

            // pistol
            case 20: return("Angle_6");

            case 21: return("Distance_6");

            // ostabcle
            case 22: return("Angle_7");

            case 23: return("Distance_7");

            // player
            case 24: return("Angle_8");

            case 25: return("Distance_8");

            // default
            default: throw new Exception("Unknown column : " + column);
            }
        }
Пример #11
0
        public static float Feature(this ModelDataSet data, int column)
        {
            switch (column)
            {
            case 0: return(data.CenterAngle);

            case 1: return(data.InZone);

            case 2: return(data.Health);

            case 3: return(data.Shield);

            case 4: return(data.Primary);

            case 5: return(data.PrimaryAmmo);

            case 6: return(data.PrimaryClip);

            case 7: return(data.Secondary);

            case 8: return(data.SecondaryAmmo);

            case 9: return(data.SecondaryClip);

            // ammo
            case 10: return(data.Angle_1);

            case 11: return(data.Distance_1);

            // bandage
            case 12: return(data.Angle_2);

            case 13: return(data.Distance_2);

            // helmet
            case 14: return(data.Angle_3);

            case 15: return(data.Distance_3);

            // ak47
            case 16: return(data.Angle_4);

            case 17: return(data.Distance_4);

            // shotgun
            case 18: return(data.Angle_5);

            case 19: return(data.Distance_5);

            // pistol
            case 20: return(data.Angle_6);

            case 21: return(data.Distance_6);

            // ostabcle
            case 22: return(data.Angle_7);

            case 23: return(data.Distance_7);

            // player
            case 24: return(data.Angle_8);

            case 25: return(data.Distance_8);

            // default
            default: throw new Exception("Unknown column : " + column);
            }
        }