Example #1
0
        public DataPoint BuildDataPoint(List <Match> history, Match m, DataInterpretation inputInpertretation)
        {
            var datapoint = new DataPoint
            {
                Inputs    = (BuildInputs(history, m, inputInpertretation)),
                Outputs   = BuildOutputs(m).ToList(),
                Reference = m.ToTuple()
            };

            return(datapoint);
        }
Example #2
0
        public static List <double> BuildInputs(List <Match> history, Match m, DataInterpretation interpretation = null)
        {
            if (interpretation == null)
            {
                interpretation = AFLDataInterpreter.BespokeLegacyInterpretation;
            }

            var input = AFLDataInterpreterTotal.New().BuildInputs(history, m, interpretation);

            return(input);
        }
Example #3
0
        public List <double> BuildInputs(List <Match> history, Match m, DataInterpretation interpretation)
        {
            var input = new List <double>();

            //Scores By Team
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_TEAM).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractTeamScoreInputSet(m, history, term, ExtractInputSetForScore));
                }
            }

            //Scores By Ground
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_GROUND).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractGroundScoreInputSet(m, history, term, ExtractInputSetForScore));
                }
            }

            //Scores By State longerTerm
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_STATE).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractStateScoreInputSet(m, history, term, ExtractInputSetForScore));
                }
            }

            //Scores by Day
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_DAY).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractDayScoreInputSet(m, history, term, ExtractInputSetForScore));
                }
            }

            //Recent Shared Opponents
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_SHARED_OPPONENTS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractSharedOpponentScoreSet(m, history, term, ExtractInputSetForScore));
                }
            }

            //Scores by quality of recent Opponents
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORES_BY_QUALITY_OF_OPPONENTS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractQualityOfRecentOpponentScoreSet(m, history, term, ExtractInputSetForOppositionScore));
                }
            }

            //Wins By Team
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.WINS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractTeamWinInputSet(m, history, term, ExtractInputSetForWin));
                }
            }

            //Scoring shots
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.SCORING_SHOTS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractScoresInputSet(m, history, term));
                }
            }

            //Kicks
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.KICKS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractKicksInputSet(m, history, term));
                }
            }

            //Handballs
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.HANDBALLS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractHandballsInputSet(m, history, term));
                }
            }

            //Marks
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.MARKS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractMarksInputSet(m, history, term));
                }
            }

            //Hitouts
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.HITOUTS).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractHitoutsInputSet(m, history, term));
                }
            }

            //Tackles
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.TACKLES).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractTacklesInputSet(m, history, term));
                }
            }

            //Frees
            foreach (var term in interpretation.Rules.Where(r => r.Type == DataInterpretationRuleType.FREES).SelectMany(r => r.Periods))
            {
                if (term > 0)
                {
                    input.AddRange(ExtractFreesInputSet(m, history, term));
                }
            }

            return(input);
        }
Example #4
0
        public static Data GetMatchDataBetween(List <Season> seasons, RoundShell fromRoundShell, RoundShell toRoundShell, DataInterpretation interpretation = null)
        {
            var data = new Data();
            //TODO: It's a little messy to new this up here
            var league  = new League(seasons);
            var rounds  = league.GetRounds(0, 0, toRoundShell.Year, toRoundShell.Number).Where(x => x.Matches.Count > 0).ToList();
            var matches = rounds.Where(r => (r.EffectiveId() > fromRoundShell.EffectiveId()))
                          .SelectMany(r => r.Matches);

            foreach (var m in matches)
            {
                var dataPoint = new DataPoint();
                var history   =
                    rounds.Where(r => !r.Matches.Any(rm => rm.Date >= m.Date)).SelectMany(r => r.Matches).ToList();
                dataPoint.Inputs  = (BuildInputs(history, m, interpretation));
                dataPoint.Outputs = (new List <double>()
                {
                    Numbery.Normalise(m.HomeScore().Total(), Util.MaxScore),
                    Numbery.Normalise(m.AwayScore().Total(), Util.MaxScore)
                });
                dataPoint.Reference = m.ToTuple();
                data.DataPoints.Add(dataPoint);
            }
            return(data);
        }
Example #5
0
 public Data GetMatchDataFromLeagueBetween(RoundShell fromRoundShell, RoundShell toRoundShell, DataInterpretation interpretation = null)
 {
     return(GetMatchDataBetween(League.Seasons, fromRoundShell, toRoundShell, interpretation));
 }
Example #6
0
        public List <PredictedMatch> PredictWinners(int year, int round, bool isFinal, DataInterpretation interpretation = null)
        {
            var predictions = new List <PredictedMatch>();
            var rounds      = League.GetRounds(0, 0, year, round).Where(x => x.Matches.Count > 0).ToList();

            foreach (var m in rounds.Where(r => r.Year == year && r.Number == round && r.IsFinal == isFinal).SelectMany(r => r.Matches))
            {
                //TODO: Are we ordering in the right direction?
                var history =
                    rounds.Where(r => !r.Matches.Any(rm => rm.Date >= m.Date)).SelectMany(r => r.Matches).OrderBy(h => h.Date).ToList();

                var test = BuildInputs(history, m, interpretation);

                var result = Net.Run(test);

                predictions.Add(new PredictedMatch(m.Home, m.Away, m.Ground, m.Date, Numbery.Denormalise(result[0], Util.MaxScore), Numbery.Denormalise(result[1], Util.MaxScore), round));
            }
            return(predictions);
        }