1
restaurant-search/util.go
2015-06-28 16:34:58 +09:00

302 lines
8.0 KiB
Go

/*
* Copyright (c) 2015 Alex Yatskov <alex@foosoft.net>
* Author: Alex Yatskov <alex@foosoft.net>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package main
import (
"log"
"math"
"strconv"
"github.com/kellydunn/golang-geo"
)
func fixFeatures(features featureMap) featureMap {
fixedFeatures := featureMap{
"nearby": 0.0,
"accessible": 0.0,
"delicious": 0.0,
"accommodating": 0.0,
"affordable": 0.0,
"atmospheric": 0.0}
for name, _ := range fixedFeatures {
value, _ := features[name]
fixedFeatures[name] = value
}
return fixedFeatures
}
func innerProduct(features1 featureMap, features2 featureMap) float64 {
var result float64
for key, value1 := range features1 {
value2, _ := features2[key]
result += value1 * value2
}
return result
}
func walkMatches(entries records, features featureMap, minScore float64, callback func(record, float64)) {
for _, entry := range entries {
if score := innerProduct(features, entry.features); score >= minScore {
callback(entry, score)
}
}
}
func statRecords(entries records, features featureMap, minScore float64) (float64, int) {
var compatibility float64
var count int
walkMatches(entries, features, minScore, func(entry record, score float64) {
compatibility += entry.compatibility
count++
})
return compatibility, count
}
func stepRange(min, max float64, steps int, callback func(float64)) {
stepSize := (max - min) / float64(steps)
for i := 0; i < steps; i++ {
stepMax := max - stepSize*float64(i)
stepMin := stepMax - stepSize
stepMid := (stepMin + stepMax) / 2
callback(stepMid)
}
}
func findRecords(entries records, features featureMap, minScore float64) records {
var foundEntries records
walkMatches(entries, features, minScore, func(entry record, score float64) {
entry.score = score
foundEntries = append(foundEntries, entry)
})
return foundEntries
}
func calibrateMinScore(entries records, features featureMap, bracket namedBracket) float64 {
bestScoreRank := -math.MaxFloat64
var bestMinScore float64
for minScore := float64(-len(features)); minScore <= float64(len(features)); minScore += 0.1 {
var scoreRank float64
for _, entry := range entries {
value, ok := entry.features[bracket.name]
if !ok {
continue
}
score := innerProduct(features, entry.features)
if score < minScore {
continue
}
if score > minScore {
if value >= bracket.min && value <= bracket.max {
dist := math.Abs(value - features[bracket.name])
scoreRank += 1 / (dist * dist)
} else {
dist := math.Min(math.Abs(value-bracket.min), math.Abs(value-bracket.max))
scoreRank -= 1 / (dist * dist)
}
}
}
if scoreRank > bestScoreRank {
bestScoreRank = scoreRank
bestMinScore = minScore
}
}
log.Printf("bestScoreRank: %f; bestMinScore: %f", bestScoreRank, bestMinScore)
return bestMinScore
}
func project(entries records, features featureMap, featureName string, minScore float64, steps int) []queryProjection {
sampleFeatures := make(featureMap)
for key, value := range features {
sampleFeatures[key] = value
}
var projection []queryProjection
stepRange(-1.0, 1.0, steps, func(sample float64) {
sample, sampleFeatures[featureName] = sampleFeatures[featureName], sample
compatibility, count := statRecords(entries, sampleFeatures, minScore)
sample, sampleFeatures[featureName] = sampleFeatures[featureName], sample
projection = append(projection, queryProjection{compatibility, count, sample})
})
return projection
}
func computeRecordGeo(entries records, context queryContext) {
distUserMin := math.MaxFloat64
distUserMax := 0.0
for index := range entries {
entry := &entries[index]
if context.geo != nil {
userPoint := geo.NewPoint(context.geo.latitude, context.geo.longitude)
entryPoint := geo.NewPoint(entry.geo.latitude, context.geo.longitude)
entry.distanceToUser = userPoint.GreatCircleDistance(entryPoint)
}
distUserMin = math.Min(entry.distanceToUser, distUserMin)
distUserMax = math.Max(entry.distanceToUser, distUserMax)
}
distUserRange := distUserMax - distUserMin
for index := range entries {
entry := &entries[index]
var accessible, nearby float64
if distUserRange > 0 {
nearby = -((entry.distanceToUser-distUserMin)/distUserRange - 0.5) * 2.0
accessible = 1.0 - (entry.distanceToStn / context.walkingDist)
accessible = math.Max(accessible, -1.0)
accessible = math.Min(accessible, 1.0)
}
entry.features["nearby"] = nearby
entry.features["accessible"] = accessible
}
}
func computeRecordPopularity(entries records, context queryContext) {
for index := range entries {
entry := &entries[index]
historyRows, err := db.Query("SELECT id FROM history WHERE reviewId = (?)", entry.id)
if err != nil {
log.Fatal(err)
}
defer historyRows.Close()
var groupSum float64
var groupCount int
for historyRows.Next() {
var historyId int
if err := historyRows.Scan(&historyId); err != nil {
log.Fatal(err)
}
groupRows, err := db.Query("SELECT categoryId, categoryValue FROM historyGroups WHERE historyId = (?)", historyId)
if err != nil {
log.Fatal(err)
}
defer groupRows.Close()
recordProfile := make(featureMap)
for groupRows.Next() {
var categoryId int
var categoryValue float64
if err := groupRows.Scan(&categoryId, &categoryValue); err != nil {
log.Fatal(err)
}
recordProfile[strconv.Itoa(categoryId)] = categoryValue
}
if err := groupRows.Err(); err != nil {
log.Fatal(err)
}
groupSum += innerProduct(recordProfile, context.profile)
groupCount++
}
if err := historyRows.Err(); err != nil {
log.Fatal(err)
}
if groupCount > 0 {
entry.compatibility = groupSum / float64(groupCount)
}
}
}
func getRecords(context queryContext) records {
recordRows, err := db.Query("SELECT name, url, delicious, accommodating, affordable, atmospheric, latitude, longitude, distanceToStn, closestStn, accessCount, id FROM reviews")
if err != nil {
log.Fatal(err)
}
defer recordRows.Close()
var entries []record
for recordRows.Next() {
var name, url, closestStn string
var delicious, accommodating, affordable, atmospheric, latitude, longitude, distanceToStn float64
var accessCount, id int
recordRows.Scan(
&name,
&url,
&delicious,
&accommodating,
&affordable,
&atmospheric,
&latitude,
&longitude,
&distanceToStn,
&closestStn,
&accessCount,
&id)
entry := record{
name: name,
url: "http://www.tripadvisor.com" + url,
distanceToStn: distanceToStn,
closestStn: closestStn,
accessCount: accessCount,
geo: geoData{latitude, longitude},
id: id}
entry.features = featureMap{
"delicious": delicious,
"accommodating": accommodating,
"affordable": affordable,
"atmospheric": atmospheric}
entries = append(entries, entry)
}
if err := recordRows.Err(); err != nil {
log.Fatal(err)
}
computeRecordPopularity(entries, context)
computeRecordGeo(entries, context)
return entries
}