You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100 lines
2.6 KiB
100 lines
2.6 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
|
|
"go-common/app/job/main/reply-feed/model" |
|
"go-common/library/log" |
|
) |
|
|
|
func (s *Service) loadAlgorithm() (err error) { |
|
ss, err := s.dao.SlotStats(context.Background()) |
|
if err != nil { |
|
return |
|
} |
|
// 按name聚合slot |
|
ssMap := make(map[string]*model.SlotsStat) |
|
for _, s := range ss { |
|
if v, exists := ssMap[s.Name]; exists { |
|
v.Slots = append(v.Slots, s.Slot) |
|
} else { |
|
ssMap[s.Name] = &model.SlotsStat{ |
|
Name: s.Name, |
|
Slots: []int{s.Slot}, |
|
Algorithm: s.Algorithm, |
|
Weight: s.Weight, |
|
} |
|
} |
|
} |
|
var algorithms []model.Algorithm |
|
for name, ss := range ssMap { |
|
if ss.Weight == "" { |
|
continue |
|
} |
|
var ( |
|
algorithm model.Algorithm |
|
w interface{} |
|
) |
|
if ss.Algorithm == model.WilsonLHRRAlgorithm || ss.Algorithm == model.WilsonLHRRFluidAlgorithm { |
|
if err = json.Unmarshal([]byte(ss.Weight), &w); err != nil { |
|
log.Error("json.Unmarshal() error(%v), name (%s), algorightm (%s), weight (%s)", err, name, ss.Algorithm, ss.Weight) |
|
return |
|
} |
|
} |
|
switch ss.Algorithm { |
|
case model.WilsonLHRRAlgorithm: |
|
weight := w.(map[string]interface{}) |
|
algorithm = model.NewWilsonLHRR(name, ss.Slots, &model.WilsonLHRRWeight{ |
|
Like: weight["like"].(float64), |
|
Hate: weight["hate"].(float64), |
|
Reply: weight["reply"].(float64), |
|
Report: weight["report"].(float64), |
|
}) |
|
case model.WilsonLHRRFluidAlgorithm: |
|
weight := w.(map[string]interface{}) |
|
algorithm = model.NewWilsonLHRRFluid(name, ss.Slots, &model.WilsonLHRRFluidWeight{ |
|
Like: weight["like"].(float64), |
|
Hate: weight["hate"].(float64), |
|
Reply: weight["reply"].(float64), |
|
Report: weight["report"].(float64), |
|
Slope: weight["slope"].(float64), |
|
}) |
|
case model.OriginAlgorithm: |
|
algorithm = model.NewOrigin(name, ss.Slots) |
|
case model.LikeDescAlgorithm: |
|
algorithm = model.NewLikeDesc(name, ss.Slots) |
|
case model.DefaultAlgorithm: |
|
continue |
|
default: |
|
log.Warn("invalid algorithm") |
|
continue |
|
} |
|
if algorithm != nil { |
|
algorithms = append(algorithms, algorithm) |
|
} |
|
} |
|
s.algorithmsLock.Lock() |
|
s.algorithms = algorithms |
|
s.algorithmsLock.Unlock() |
|
return |
|
} |
|
|
|
func (s *Service) loadSlots() (err error) { |
|
ctx := context.Background() |
|
slotsMap, err := s.dao.SlotsMapping(ctx) |
|
if err != nil { |
|
return |
|
} |
|
s.statisticsLock.Lock() |
|
for name, mapping := range slotsMap { |
|
for _, slot := range mapping.Slots { |
|
s.statisticsStats[slot].Name = name |
|
s.statisticsStats[slot].Slot = slot |
|
} |
|
log.Warn("name stat (name: %s, slots: %v)", name, mapping.Slots) |
|
} |
|
log.Warn("statistics stat (%v)", s.statisticsStats) |
|
s.statisticsLock.Unlock() |
|
return |
|
}
|
|
|