コード例 #1
0
func mapToPerformanceTestSeries2(name string, predictedJourneyTimes, actualJourneyTimes map[time.Time]time.Duration) PerformanceTestSeries2 {

	departureTimes := make([]time.Time, len(predictedJourneyTimes))
	durations := make([]time.Duration, len(predictedJourneyTimes))
	i := 0

	/* For calculating the root mean squared error, and mean absolute error */
	diffInSeconds := make([]float64, 0)
	absDiffInSeconds := make([]float64, 0)

	for departureTime, duration := range predictedJourneyTimes {
		departureTimes[i] = departureTime
		durations[i] = duration

		actualJourneyTime := actualJourneyTimes[departureTime]
		diffInSeconds = append(diffInSeconds, (duration - actualJourneyTime).Seconds())
		absDiffInSeconds = append(absDiffInSeconds, math.Abs((duration - actualJourneyTime).Seconds()))

		i++
	}

	rmse, err := statistics.RootMeanSquare(absDiffInSeconds)
	if err != nil {
		/* If lack of data points simply assume 0 */
		logger.GetLogger().Error(err.Error())
		rmse = 0
	}

	mae, err := statistics.Mean(absDiffInSeconds)
	if err != nil {
		/* If lack of data points simply assume 0 */
		logger.GetLogger().Error(err.Error())
		mae = 0
	}

	mad, err := statistics.Median(absDiffInSeconds)
	if err != nil {
		/* If lack of data points simply assume 0 */
		logger.GetLogger().Error(err.Error())
		mad = 0
	}

	variance, err := statistics.Variance(diffInSeconds)
	if err != nil {
		/* If lack of data points simply assume 0 */
		logger.GetLogger().Error(err.Error())
		variance = 0
	}

	return PerformanceTestSeries2{
		SeriesName: name,
		X:          departureTimes,
		Y:          durations,
		Count:      len(durations),
		RMSE:       time.Duration(rmse) * time.Second,
		MAE:        time.Duration(mae) * time.Second,
		MAD:        time.Duration(mad) * time.Second,
		Variance:   time.Duration(variance) * time.Second,
	}
}
func computeDelayCharacteristicsForHour(hour int, times []time.Time, actualDurations []time.Duration, historicDurations []time.Duration) map[time.Duration]map[int]time.Duration {
	// Extract times and durations relavant to the hour (and < hour + 2 hours)
	truncatedTimes := make([]time.Time, 0)
	truncatedActualDurations := make([]time.Duration, 0)
	truncatedHistoricDurations := make([]time.Duration, 0)
	for i, t := range times {
		if hour <= t.Hour() && t.Hour() < hour+int(continuousObservationPeriod.Hours()) {
			truncatedTimes = append(truncatedTimes, t)
			truncatedActualDurations = append(truncatedActualDurations, actualDurations[i])
			truncatedHistoricDurations = append(truncatedHistoricDurations, historicDurations[i])
		}
	}

	// Build delay characteristics table
	delayCharacteristics := make(map[time.Duration]map[int]time.Duration)

	for _, delayThreshold := range DelayThresholds {
		delayCharacteristicsPerThreshold := make(map[int]time.Duration)
		earlyCharacteristicsPerThreshold := make(map[int]time.Duration)

		for _, busCountThreshold := range DelayBusCountThresholds {

			delaysLasting := make([]float64, 0)
			delayFlag := false
			currentDelayCount := 0

			var startOfDelay, endOfDelay time.Time

			for i, currentTime := range truncatedTimes {
				actualDuration := truncatedActualDurations[i]
				historicDuration := truncatedHistoricDurations[i]

				// Skip if comparison can't be made
				if historicDuration == 0 {
					continue
				}

				if delayFlag {

					// Handle during delay here (special case if delay still occuring at last point in time)
					if actualDuration < historicDuration+delayThreshold || i == len(truncatedTimes)-1 {
						// End of delay
						endOfDelay = currentTime

						// Safety check no bus overtakes, and not artifically large
						if endOfDelay.After(startOfDelay) && endOfDelay.Sub(startOfDelay) < 24*time.Hour {
							delayDuration := endOfDelay.Sub(startOfDelay)
							delaysLasting = append(delaysLasting, delayDuration.Seconds())
						}
						// Reset flags
						delayFlag = false
						currentDelayCount = 0
					}
				} else {
					// Handle no delay / delay not yet found here
					if actualDuration >= historicDuration+delayThreshold {
						// Accumulate until delay found
						if currentDelayCount < busCountThreshold {
							currentDelayCount++
							continue
						}
						startOfDelay = currentTime
						delayFlag = true
					}
					currentDelayCount = 0
				}
			}

			averageLastingTime, _ := statistics.Mean(delaysLasting)
			delayCharacteristicsPerThreshold[busCountThreshold] = time.Duration(averageLastingTime) * time.Second

			// Do the same for early
			earlyLasting := make([]float64, 0)
			earlyFlag := false
			currentEarlyCount := 0

			var startOfEarly, endOfEarly time.Time

			for i, currentTime := range truncatedTimes {
				actualDuration := truncatedActualDurations[i]
				historicDuration := truncatedHistoricDurations[i]

				// Skip if comparison can't be made
				if historicDuration == 0 {
					continue
				}

				if earlyFlag {

					// Handle during delay here (special case if early still occuring at last point in time)
					if actualDuration > historicDuration-delayThreshold || i == len(truncatedTimes)-1 {
						// End of early
						endOfEarly = currentTime

						// Safety check no bus overtakes, and not artifically large
						if endOfEarly.After(startOfEarly) && endOfEarly.Sub(startOfEarly) < 24*time.Hour {
							earlyDuration := endOfEarly.Sub(startOfEarly)
							earlyLasting = append(earlyLasting, earlyDuration.Seconds())
						}
						// Reset flags
						earlyFlag = false
						currentEarlyCount = 0
					}
				} else {
					// Handle no early / early not yet found here
					if actualDuration <= historicDuration-delayThreshold {
						// Accumulate until early found
						if currentEarlyCount < busCountThreshold {
							currentEarlyCount++
							continue
						}
						startOfEarly = currentTime
						earlyFlag = true
					}
					currentEarlyCount = 0
				}
			}

			averageEarly, _ := statistics.Mean(earlyLasting)
			earlyCharacteristicsPerThreshold[busCountThreshold] = time.Duration(averageEarly) * time.Second
		}
		delayCharacteristics[delayThreshold] = delayCharacteristicsPerThreshold
		delayCharacteristics[-delayThreshold] = earlyCharacteristicsPerThreshold
	}
	return delayCharacteristics
}
コード例 #3
0
/* Writes to .html file for resulting performance graph */
func writePerformanceChart2(wr io.Writer, summary PerformancePlotSummary2, templatePath string) {

	funcMap := template.FuncMap{
		// Prettifies x and y axes into js format
		"formatXAxis": func(i int, slice []time.Time) string {
			str := fmt.Sprintf("['x%v'", i)
			for i := 0; i < len(slice); i++ {
				str += ", " + fmt.Sprintf("new Date(Date.UTC(%v, %v, %v, %v, %v, %v))",
					slice[i].Year(), int(slice[i].Month())-1, slice[i].Day(),
					slice[i].Hour(), slice[i].Minute(), slice[i].Second())
			}
			str += "]"
			return str
		},
		"formatYAxis": func(seriesName string, slice []time.Duration) string {
			str := fmt.Sprintf("['%v'", seriesName)
			for i := 0; i < len(slice); i++ {
				minutes := int(slice[i].Minutes())
				if minutes == 0 {
					str += ", null"
				} else {
					str += ", " + strconv.Itoa(minutes)
				}
			}
			str += "]"
			return str
		},
		"formatRMSE": func(rmse time.Duration) string {
			if rmse > 0 {
				return rmse.String()
			}
			return "NA"
		},
		"getOverallRMSE": func(heuristic string, method performanceeval.Method, charts []PerformanceChart2) string {
			percentageRMSEs := make([]float64, 0)
			for _, chart := range charts {
				/* First find out error between tfl and actual */
				var tflHeuristicError time.Duration
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == "Tfl Expected Time" {
						switch heuristic {
						case "RMSE":
							tflHeuristicError = series.RMSE
						case "MAE":
							tflHeuristicError = series.MAE
						case "MAD":
							tflHeuristicError = series.MAD
						case "Variance":
							tflHeuristicError = series.Variance
						default:
							logger.GetLogger().Panicf("Unknown heuristic: %v", heuristic)

						}
					}
				}

				/* Find out error between method and actual */
				var heuristicError time.Duration
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == method.String() {
						switch heuristic {
						case "RMSE":
							heuristicError = series.RMSE
						case "MAE":
							heuristicError = series.MAE
						case "MAD":
							heuristicError = series.MAD
						case "Variance":
							heuristicError = series.Variance
						default:
							logger.GetLogger().Panicf("Unknown heuristic: %v", heuristic)
						}
					}
				}

				/* Skip if either is invalid */
				if heuristicError == 0 || tflHeuristicError == 0 {
					continue
				}

				/* Calculate percentage error as that of tfl */
				percentError := (tflHeuristicError.Seconds() - heuristicError.Seconds()) / tflHeuristicError.Seconds()
				percentageRMSEs = append(percentageRMSEs, percentError)
			}
			overallPercentRMSE, err := statistics.Mean(percentageRMSEs)
			if err != nil {
				return "NA"
			}
			return fmt.Sprintf("%0.2f%%", overallPercentRMSE*100)
		},
		/* Counts the number of journeys which are superior than the tfl expected time for a particular prediction method */
		"getSuperiorCount": func(heuristic string, method performanceeval.Method, charts []PerformanceChart2) int {
			count := 0
			for _, chart := range charts {
				/* First find out error between tfl and actual */
				var tflHeuristicError time.Duration
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == "Tfl Expected Time" {
						switch heuristic {
						case "RMSE":
							tflHeuristicError = series.RMSE
						case "MAE":
							tflHeuristicError = series.MAE
						case "MAD":
							tflHeuristicError = series.MAD
						case "Variance":
							tflHeuristicError = series.Variance
						default:
							logger.GetLogger().Panicf("Unknown heuristic: %v", heuristic)

						}
					}
				}

				/* Find out error between method and actual */
				var heuristicError time.Duration
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == method.String() {
						switch heuristic {
						case "RMSE":
							heuristicError = series.RMSE
						case "MAE":
							heuristicError = series.MAE
						case "MAD":
							heuristicError = series.MAD
						case "Variance":
							heuristicError = series.Variance
						default:
							logger.GetLogger().Panicf("Unknown heuristic: %v", heuristic)
						}
					}
				}

				/* Skip if either is invalid */
				if heuristicError == 0 || tflHeuristicError == 0 {
					continue
				}

				if heuristicError < tflHeuristicError {
					count++
				} else if heuristicError > tflHeuristicError {
					count--
				}
			}
			return count
		},
		/* Returns the average % count of data points available of a particular prediction method with respect to the actual times*/
		"getAverageAvailableDataPoints": func(method performanceeval.Method, charts []PerformanceChart2) string {
			percentages := make([]float64, 0)
			for _, chart := range charts {
				/* First find out count for actual series */
				var actualCount int
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == "Actual Time" {
						actualCount = series.Count
					}
				}

				/* Find out count for method*/
				var methodCount int
				for _, series := range chart.MultipleSeries {
					if series.SeriesName == method.String() {
						methodCount = series.Count
					}
				}

				/* Prevent zero numerator or denominator */
				if methodCount != 0 && actualCount != 0 {
					percentages = append(percentages, float64(methodCount)/float64(actualCount))
				}
			}
			averagePercentage, err := statistics.Mean(percentages)
			if err != nil {
				return "NA"
			}
			return fmt.Sprintf("%.2f%%", averagePercentage*100)
		},
	}

	t, err := template.New(path.Base(templatePath)).Funcs(funcMap).ParseFiles(templatePath)
	if err != nil {
		logger.GetLogger().Panic(err)
	}

	err = t.Execute(wr, summary)
	if err != nil {
		logger.GetLogger().Panic(err)
	}
}
コード例 #4
0
/* Returns map[string]map[string]map[string]int
   ( map : fromStop =>
   		(map : toStop =>
   			(map : "estimate" => estimate in seconds
   			       "stddev" => standard deviation in seconds
   			       "delayBusCount" => bus count as evidence of delay
   			       "delayExpectedToLast" => how long delay is expected to last in seconds
   			 )
   		)
   	)
   	the estimated journey times, standard deviation, between map of neighbouring stops
   	for mixed, historic and real time.
*/
func getEstimates(adjacentStops map[string]map[string]bool) (map[string]map[string]map[string]int, map[string]map[string]map[string]int, map[string]map[string]map[string]int) {
	departureTime := time.Now().In(timezone.Get())

	timeRanges := map[time.Time]time.Time{
		departureTime.AddDate(0, 0, -7).Add(-30 * time.Minute):  departureTime.AddDate(0, 0, -7).Add(30 * time.Minute),
		departureTime.AddDate(0, 0, -14).Add(-30 * time.Minute): departureTime.AddDate(0, 0, -14).Add(30 * time.Minute),
		departureTime.AddDate(0, 0, -21).Add(-30 * time.Minute): departureTime.AddDate(0, 0, -21).Add(30 * time.Minute),
	}

	realTimeEstimates := make(map[string]map[string]map[string]int)
	mixedEstimates := make(map[string]map[string]map[string]int)

	/* Select historic and real time estimates from database */
	historicEstimates := selectdb.SelectHistoricEstimates(timeRanges)
	realTimeData := selectdb.SelectRealTimeEstimates(realTimeWindow)

	/* Combine historic and real time data */
	for fromStop, fromStopDetails := range historicEstimates {
		for toStop, historicDetails := range fromStopDetails {
			historicEstimate := time.Duration(historicDetails["estimate"]) * time.Second

			/* Extract real time data and lookup delay characteristics, skip for cases lacking real time estimate */
			delayBusCount := 0
			realTimeFromStopDetails, exists := realTimeData[fromStop]
			if !exists {
				continue
			}
			realTimeDetails, exists := realTimeFromStopDetails[toStop]
			if !exists {
				continue
			}
			realTimeCount, _ := realTimeDetails["count"]
			if realTimeCount < 3 {
				continue
			}
			realTimeRecords := make([]time.Duration, realTimeCount)
			for i := 1; i <= realTimeCount; i++ {
				// Since real time records are already reversed, reverse it again for ascending order in time,
				// so that handleDelayReverseLookup will work fine
				realTimeRecord := time.Duration(realTimeDetails[strconv.Itoa(realTimeCount+1-i)]) * time.Second
				realTimeRecords[i-1] = realTimeRecord
			}

			/* Calculate real time estimate using last three buses averaged */
			realTimeLastThreeInSeconds := make([]float64, 3)
			for j := 0; j < 3; j++ {
				realTimeLastThreeInSeconds[j] = realTimeRecords[len(realTimeRecords)-1-j].Seconds()
			}
			realTimeEstimateInSeconds, _ := statistics.Mean(realTimeLastThreeInSeconds)
			_, exists = realTimeEstimates[fromStop]
			if !exists {
				realTimeEstimates[fromStop] = make(map[string]map[string]int)
				mixedEstimates[fromStop] = make(map[string]map[string]int)
			}
			realTimeEstimates[fromStop][toStop] = map[string]int{
				"estimate": int(realTimeEstimateInSeconds),
			}

			/* Get mixed estimates below */

			shouldUseHistoric, delayBusCount, delayExpectedToLast := performanceeval.HandleDelayReverseLookup(
				fromStop, toStop, departureTime, delayLastingThreshold, historicEstimate, realTimeRecords)

			if shouldUseHistoric {
				mixedEstimates[fromStop][toStop] = historicEstimates[fromStop][toStop]
				mixedEstimates[fromStop][toStop]["delayBusCount"] = delayBusCount
			} else {
				mixedEstimates[fromStop][toStop] = map[string]int{
					"estimate":            int(realTimeEstimateInSeconds),
					"delayBusCount":       delayBusCount,
					"delayExpectedToLast": int(delayExpectedToLast.Seconds()),
					"delay":               1,
				}
			}
		}
	}
	return mixedEstimates, historicEstimates, realTimeEstimates
}