init

adv/pairs.go

@@ -0,0 +1,922 @@
+package adv
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"path/filepath"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"gonum.org/v1/gonum/floats"
+
+	"go.uber.org/zap"
+
+	"github.com/banbox/banbot/biz"
+	"github.com/banbox/banbot/btime"
+	"github.com/banbox/banbot/config"
+	"github.com/banbox/banbot/core"
+	"github.com/banbox/banbot/entry"
+	"github.com/banbox/banbot/opt"
+	"github.com/banbox/banbot/orm"
+	"github.com/banbox/banbot/orm/ormo"
+	utils2 "github.com/banbox/banbot/utils"
+	"github.com/banbox/banexg/errs"
+	"github.com/banbox/banexg/log"
+	"github.com/banbox/banexg/utils"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	runConfig := func(args *config.CmdArgs, run func(*config.CmdArgs) *errs.Error) error {
+		core.SetRunMode(core.RunModeOther)
+		args.Init()
+		return run(args)
+	}
+	bindCommon := func(command *cobra.Command, args *config.CmdArgs) {
+		flags := command.Flags()
+		flags.StringArrayVar((*[]string)(&args.Configs), "config", nil, "config path; may be repeated")
+		flags.StringVar(&args.ConfigData, "config-data", "", "inline YAML config")
+		flags.StringVar(&args.Logfile, "logfile", "", "log file path")
+		flags.StringVar(&args.DataDir, "datadir", "", "path to the data directory")
+		flags.BoolVar(&args.NoDefault, "no-default", false, "ignore config.yml and config.local.yml")
+		flags.StringVar(&args.LogLevel, "level", "info", "logging level")
+		flags.IntVar(&args.MaxPoolSize, "max-pool-size", 0, "maximum database pool size")
+		flags.BoolVar(&core.NetDisable, "net-off", false, "disable network requests")
+	}
+	newConfigCommand := func(name, help string, run func(*config.CmdArgs) *errs.Error,
+		bind func(*cobra.Command, *config.CmdArgs)) *cobra.Command {
+		args := &config.CmdArgs{}
+		command := &cobra.Command{
+			Use:   name,
+			Short: help,
+			Args:  cobra.NoArgs,
+			RunE: func(_ *cobra.Command, _ []string) error {
+				return runConfig(args, run)
+			},
+		}
+		bindCommon(command, args)
+		if bind != nil {
+			bind(command, args)
+		}
+		return command
+	}
+
+	dayRets := newConfigCommand("dayRets", "calc return rate for pairs by months", CalcPairDayPerfs,
+		func(command *cobra.Command, args *config.CmdArgs) {
+			command.Flags().StringVar(&args.InPath, "in", "", "input file or directory")
+		})
+	entry.AddCommand("tool", dayRets)
+
+	entry.AddCommand("tool", newConfigCommand("updMkt", "update coin markets by month", UpdateCoinMarkets, nil))
+	entry.AddCommand("tool", newConfigCommand("buildFac", "build factor samples", BuildFacSamples, nil))
+	entry.AddCommand("tool", &cobra.Command{
+		Use:                "testFac",
+		Short:              "test factors",
+		DisableFlagParsing: true,
+		RunE: func(_ *cobra.Command, args []string) error {
+			return TestFactors(args)
+		},
+	})
+}
+
+var urlCoinMarket = "https://api.coinmarketcap.com/data-api/v3/cryptocurrency/listings/historical?convertId=2781&date=%s&limit=%d&start=%d"
+var coinSlugMap = map[string]string{
+	"BTCDOM":    "",
+	"1000XEC":   "ecash",
+	"LUNA2":     "terra-luna-v2",
+	"DODOX":     "dodo",
+	"BEAMX":     "onbeam",
+	"1000RATS":  "",
+	"RONIN":     "ronin",
+	"1000SHIB":  "shiba-inu",
+	"1000LUNC":  "terra-luna",
+	"1000FLOKI": "floki-inu",
+	"1000PEPE":  "pepe",
+	"1000BONK":  "bonk1",
+}
+
+type PairReturns struct {
+	StartMS int64
+	EndMS   int64
+	Pairs   map[string]*ItemReturns
+}
+
+type ItemReturns struct {
+	StartMS int64
+	EndMS   int64
+	Arr     []float64
+}
+
+type CoinMarket struct {
+	Name      string         `json:"name"`
+	Symbol    string         `json:"symbol"`
+	ListMS    int64          `json:"list_ms"`
+	Slug      string         `json:"slug"`
+	FirstMS   int64          `json:"first_ms"`
+	LastMS    int64          `json:"last_ms"`
+	MarketHis []*MarketSlice `json:"market_his"`
+}
+
+type MarketSlice struct {
+	TimeMS            int64   `json:"time_ms"`
+	CirculatingSupply float64 `json:"circulating_supply"`
+	TotalSupply       float64 `json:"total_supply"`
+	Price             float64 `json:"price"`
+	MarketCap         float64 `json:"market_cap"`
+}
+
+type CoinMarketHis struct {
+	Coins map[string]*CoinMarket
+	Times []int64
+}
+
+type CoinMarketResponse struct {
+	Data []struct {
+		ID                int     `json:"id"`
+		Name              string  `json:"name"`
+		Symbol            string  `json:"symbol"`
+		Slug              string  `json:"slug"`
+		DateAdded         string  `json:"dateAdded"`
+		CirculatingSupply float64 `json:"circulatingSupply"`
+		TotalSupply       float64 `json:"totalSupply"`
+		Quotes            []struct {
+			Name      string  `json:"name"`
+			Price     float64 `json:"price"`
+			MarketCap float64 `json:"marketCap"`
+		} `json:"quotes"`
+	} `json:"data"`
+	Status struct {
+		ErrorCode    string `json:"error_code"`
+		ErrorMessage string `json:"error_message"`
+	} `json:"status"`
+}
+
+/*
+某个品种在某个时间的历史收益，市场、未来回报等信息
+*/
+type PairSample struct {
+	Offset    int // 值int是在ItemReturns.Arr的位置索引
+	Pair      string
+	Code      string
+	Price     float64
+	MarketCap float64
+	Vols      []float64
+}
+
+type FacHis struct {
+	Times []int64
+	Pairs map[string]*ItemReturns
+	Data  map[int64]map[string]*PairSample // time: pair: sample
+}
+
+type FacState struct {
+	Ret      *ItemReturns
+	Sample   *PairSample
+	Groups   map[string]string
+	Label    string
+	Tmp      float64 // 因子计算临时使用
+	OutScore float64 // 输出分数
+	OutID    int     // 输出分数排序序号
+}
+
+type GpState struct {
+	count    float64 // 该块中FacState的数量
+	sumScore float64 // 该块的平均分数
+}
+
+/*
+CalcPairDayPerfs 从订单计算每个品种的每日收益率
+*/
+func CalcPairDayPerfs(args *config.CmdArgs) *errs.Error {
+	err := biz.SetupComs(args)
+	if err != nil {
+		return err
+	}
+	orders, err := ormo.LoadOrdersGob(args.InPath)
+	if err != nil {
+		return err
+	}
+	pairOrders := make(map[string][]*ormo.InOutOrder)
+	minTimeMS, maxTimeMS := btime.TimeMS(), int64(0)
+	totalCost := float64(0)
+	for _, o := range orders {
+		odList, _ := pairOrders[o.Symbol]
+		pairOrders[o.Symbol] = append(odList, o)
+		minTimeMS = min(minTimeMS, o.Enter.CreateAt)
+		maxTimeMS = max(maxTimeMS, o.Exit.CreateAt)
+		totalCost += o.EnterCost() / o.Leverage
+	}
+	// 假设初始金额能同时开50笔
+	initStake := totalCost / float64(len(orders)) * 50
+	// 解析开始时间和结束时间，对齐到月的1号
+	startYear, startMon, _ := btime.MSToTime(minTimeMS).Date()
+	endYear, endMon, endDay := btime.MSToTime(maxTimeMS).Date()
+	endAddMon := 0
+	if endDay > 1 {
+		endAddMon = 1
+	}
+	startMS := time.Date(startYear, startMon, 1, 0, 0, 0, 0, time.UTC).UnixMilli()
+	endTime := time.Date(endYear, endMon, 1, 0, 0, 0, 0, time.UTC)
+	endMS := endTime.AddDate(0, endAddMon, 0).UnixMilli()
+	symbolMap := orm.GetExSymbolMap(core.ExgName, core.Market)
+	dayMSecs := int64(utils.TFToSecs("1d") * 1000)
+	retMap := make(map[string]*ItemReturns)
+	var addNum int
+	for pair, odList := range pairOrders {
+		sort.Slice(odList, func(i, j int) bool {
+			a, b := odList[i], odList[j]
+			return a.Enter.CreateAt < b.Enter.CreateAt
+		})
+		exs := symbolMap[pair]
+		_, bars, err := orm.GetOHLCV(exs, "1d", startMS, endMS, 0, false)
+		if err != nil {
+			return err
+		}
+		var closes []float64
+		if len(bars) > 0 {
+			bars, addNum = utils2.FillOHLCVLacks(bars, startMS, endMS, dayMSecs)
+			if addNum > 0 {
+				log.Info("fill ohlcv lack", zap.String("pair", pair), zap.Int("num", addNum))
+			}
+			closes = make([]float64, len(bars))
+			for i, b := range bars {
+				closes[i] = b.Close
+			}
+		}
+		// 计算每日回报率
+		returns, dayOff, dayEnd := ormo.CalcUnitReturns(odList, closes, startMS, endMS, dayMSecs)
+		retRates := make([]float64, len(returns))
+		for i, ret := range returns {
+			retRates[i] = ret / initStake
+		}
+		retMap[pair] = &ItemReturns{
+			StartMS: startMS + int64(dayOff)*dayMSecs,
+			EndMS:   startMS + int64(dayEnd)*dayMSecs,
+			Arr:     retRates[dayOff:dayEnd],
+		}
+	}
+	outPath := filepath.Join(filepath.Dir(args.InPath), "out.gob")
+	return utils2.EncodeGob(outPath, &PairReturns{
+		StartMS: startMS,
+		EndMS:   endMS,
+		Pairs:   retMap,
+	})
+}
+
+func loadHisMarkets() (*CoinMarketHis, string, *errs.Error) {
+	path := filepath.Join(config.GetDataDir(), "cryptoMarkets.gob")
+	var data = &CoinMarketHis{
+		Coins: make(map[string]*CoinMarket),
+		Times: make([]int64, 0),
+	}
+	err := utils2.DecodeGobFile(path, data)
+	if err != nil {
+		return data, path, err
+	}
+	return data, path, nil
+}
+
+/*
+UpdateCoinMarkets 更新BanDataDir目录下的cryptoMarkets.gob全币种市场信息。每个月更新一次。
+*/
+func UpdateCoinMarkets(args *config.CmdArgs) *errs.Error {
+	err := biz.SetupComs(args)
+	if err != nil {
+		return err
+	}
+	data, path, err := loadHisMarkets()
+	if err != nil {
+		log.Warn("load cryptoMarkets error", zap.Error(err))
+	}
+
+	// 确定开始时间
+	startTime := time.Date(2014, 1, 1, 0, 0, 0, 0, time.UTC)
+	if len(data.Times) > 0 {
+		startTime = time.UnixMilli(data.Times[len(data.Times)-1]).UTC().AddDate(0, 1, 0)
+	}
+	lastTimeMS := startTime.AddDate(0, -1, 0).UnixMilli()
+	batchSize := 2000
+	isLast := false
+
+	// 循环获取每个月的数据
+	for {
+		if startTime.After(time.Now()) {
+			pyear, pmon, pday := time.Now().UTC().Date()
+			startTime = time.Date(pyear, pmon, pday, 0, 0, 0, 0, time.UTC).AddDate(0, 0, -1)
+			isLast = true
+		}
+
+		// 获取该月所有币种数据
+		monthData := make(map[string]*MarketSlice)
+		start := 1
+		fetchNum, fixLack := 0, 0
+		timeMS := startTime.UnixMilli()
+		for {
+			url := fmt.Sprintf(urlCoinMarket, startTime.Format("2006-01-02"), batchSize, start)
+
+			time.Sleep(time.Second * 1)
+			resp, err_ := http.Get(url)
+			log.Info("request", zap.String("url", url))
+			if err_ != nil {
+				return errs.New(errs.CodeNetFail, err_)
+			}
+
+			body, err_ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			if err_ != nil {
+				return errs.New(errs.CodeNetFail, err_)
+			}
+
+			var rsp CoinMarketResponse
+			if err_ = utils.Unmarshal(body, &rsp, utils.JsonNumAuto); err_ != nil {
+				return errs.New(errs.CodeUnmarshalFail, err_)
+			}
+
+			if rsp.Status.ErrorCode != "0" {
+				return errs.NewMsg(errs.CodeRunTime, "code: %v, msg: %v", rsp.Status.ErrorCode, rsp.Status.ErrorMessage)
+			}
+
+			if len(rsp.Data) == 0 {
+				break
+			}
+
+			for _, coin := range rsp.Data {
+				slice := &MarketSlice{
+					TimeMS:            timeMS,
+					CirculatingSupply: coin.CirculatingSupply,
+					TotalSupply:       coin.TotalSupply,
+				}
+				if len(coin.Quotes) > 0 {
+					slice.Price = coin.Quotes[0].Price
+					slice.MarketCap = coin.Quotes[0].MarketCap
+				}
+				monthData[coin.Slug] = slice
+
+				// 更新或创建币种信息
+				if cm, exists := data.Coins[coin.Slug]; exists {
+					if len(cm.MarketHis) == 0 || timeMS > cm.MarketHis[len(cm.MarketHis)-1].TimeMS {
+						// 检查是否有缺失的月份数据需要补充
+						if !isLast {
+							if cm.LastMS < lastTimeMS {
+								fixLack += 1
+								lastSlice := cm.MarketHis[len(cm.MarketHis)-1]
+								// 从上次更新的下个月开始，直到上个月为止，补充所有缺失的月份
+								curTime := time.UnixMilli(cm.LastMS).UTC().AddDate(0, 1, 0)
+								for curTime.UnixMilli() <= lastTimeMS {
+									newSlice := &MarketSlice{
+										TimeMS:            curTime.UnixMilli(),
+										CirculatingSupply: lastSlice.CirculatingSupply,
+										TotalSupply:       lastSlice.TotalSupply,
+										Price:             lastSlice.Price,
+										MarketCap:         lastSlice.MarketCap,
+									}
+									cm.MarketHis = append(cm.MarketHis, newSlice)
+									cm.LastMS = curTime.UnixMilli()
+									curTime = curTime.AddDate(0, 1, 0)
+								}
+							}
+							// 添加当前月份的数据
+							cm.MarketHis = append(cm.MarketHis, slice)
+							cm.LastMS = timeMS
+						}
+						if cm.Name != coin.Name {
+							cm.Name = coin.Name
+						}
+						if cm.Symbol != coin.Symbol {
+							cm.Symbol = coin.Symbol
+						}
+						fetchNum += 1
+					}
+				} else if !isLast {
+					listTime, _ := time.Parse("2006-01-02T15:04:05.000Z", coin.DateAdded)
+					data.Coins[coin.Slug] = &CoinMarket{
+						Name:      coin.Name,
+						Symbol:    coin.Symbol,
+						ListMS:    listTime.UnixMilli(),
+						Slug:      coin.Slug,
+						FirstMS:   timeMS,
+						LastMS:    timeMS,
+						MarketHis: []*MarketSlice{slice},
+					}
+					fetchNum += 1
+				}
+			}
+
+			// 这里可能返回数量不足batchSize个，但不代表结束了，继续请求返回为空才表示结束
+			start += batchSize
+		}
+
+		// 添加时间戳
+		data.Times = append(data.Times, timeMS)
+
+		// 保存数据
+		if err := utils2.EncodeGob(path, data); err != nil {
+			log.Error("save market data failed", zap.Error(err))
+			return err
+		} else {
+			log.Info("update coin markets ok", zap.String("date", startTime.Format("2006-01-02")),
+				zap.Int("fetch_num", fetchNum), zap.Int("fixLack", fixLack))
+		}
+
+		// 移动到下一个月
+		lastTimeMS = timeMS
+		startTime = startTime.AddDate(0, 1, 0)
+		if isLast {
+			break
+		}
+	}
+	return nil
+}
+
+/*
+BuildFacSamples 构建因子定期采样历史
+*/
+func BuildFacSamples(args *config.CmdArgs) *errs.Error {
+	err := biz.SetupComs(args)
+	if err != nil {
+		return err
+	}
+	data, _, err := loadHisMarkets()
+	if err != nil {
+		return err
+	}
+	retData := &PairReturns{Pairs: make(map[string]*ItemReturns)}
+	retPath := "E:\\trade\\go\\bandata\\backtest\\383f7dc32a_all_pairs\\out.gob"
+	if !utils2.Exists(retPath) {
+		args.InPath = filepath.Join(filepath.Dir(retPath), "orders.gob")
+		err = CalcPairDayPerfs(args)
+		if err != nil {
+			return err
+		}
+	}
+	err = utils2.DecodeGobFile(retPath, retData)
+	if err != nil {
+		return err
+	}
+	if len(retData.Pairs) == 0 {
+		return errs.NewMsg(errs.CodeRunTime, "no Pairs for PairReturns")
+	}
+	res := &FacHis{Pairs: retData.Pairs, Data: make(map[int64]map[string]*PairSample)}
+	startMS := retData.StartMS
+
+	// 构建Symbol到CoinMarket的映射
+	var b strings.Builder
+	symbolToCoin := make(map[string]*CoinMarket)
+	badCoins := make(map[string]bool)
+	skipCoins := make(map[string]bool)
+	dupCoins := make(map[string][]string)
+	for _, coin := range data.Coins {
+		if old, ok := symbolToCoin[coin.Symbol]; ok {
+			dups, _ := dupCoins[coin.Symbol]
+			if len(dups) == 0 {
+				dups = append(dups, old.Slug)
+			}
+			dupCoins[coin.Symbol] = append(dups, coin.Slug)
+			continue
+		}
+		symbolToCoin[coin.Symbol] = coin
+		b.WriteString(coin.Symbol)
+		b.WriteString(", ")
+	}
+	symbolMap := orm.GetExSymbolMap(core.ExgName, core.Market)
+	log.Info("all coins", zap.String("v", b.String()))
+	if len(dupCoins) > 0 {
+		log.Info("dupCoins", zap.String("v", utils2.MapToStr(dupCoins, true, 0)))
+	}
+
+	// 设置月份间隔（这里设置为3个月）
+	monNum := 2
+
+	// 将startMS转换为月初
+	startTime := time.UnixMilli(startMS).UTC()
+	startTime = time.Date(startTime.Year(), startTime.Month(), 1, 0, 0, 0, 0, time.UTC)
+	startTime = startTime.AddDate(0, monNum, 0)
+	endTime := time.UnixMilli(retData.EndMS).UTC()
+
+	// 从startTime开始遍历时间点
+	for curTime := startTime; !curTime.After(endTime); curTime = curTime.AddDate(0, monNum, 0) {
+		timeMS := curTime.UnixMilli()
+		timeMap := make(map[string]*PairSample)
+		prevTime := curTime.AddDate(0, -monNum, 0)
+		nextTime := curTime.AddDate(0, monNum, 0)
+
+		// 对每个pair的returns进行检查
+		for pair, itemRet := range retData.Pairs {
+			// 检查时间范围是否符合要求
+			if itemRet.StartMS > prevTime.UnixMilli() || itemRet.EndMS < nextTime.UnixMilli() {
+				continue
+			}
+
+			// 计算当前时间点在Arr中的索引
+			offset := int((timeMS - itemRet.StartMS) / (24 * 3600 * 1000)) // 转换为天数
+			if offset < 0 || offset >= len(itemRet.Arr) {
+				continue
+			}
+
+			// 查找对应的CoinMarket
+			baseCode, _, _, _ := core.SplitSymbol(pair)
+			coin, ok := symbolToCoin[baseCode]
+			if !ok {
+				if slug, ok := coinSlugMap[baseCode]; ok {
+					if slug == "" {
+						skipCoins[baseCode] = true
+						continue
+					}
+					coin = data.Coins[slug]
+				} else {
+					badCoins[baseCode] = true
+					continue
+				}
+			}
+
+			// 查找当前时间点对应的MarketSlice
+			var mktSlice *MarketSlice
+			for _, slice := range coin.MarketHis {
+				if slice.TimeMS <= timeMS {
+					mktSlice = slice
+				} else {
+					break
+				}
+			}
+			if mktSlice == nil {
+				// 太新，跳过
+				continue
+			}
+
+			// 获取成交量数据
+			exs := symbolMap[pair]
+			if exs == nil {
+				return errs.NewMsg(errs.CodeRunTime, "ExSymbol not exist: %v", pair)
+			}
+
+			// 计算2周和1个月的成交量
+			barStartMS := prevTime.UnixMilli()
+			_, bars, err := orm.GetOHLCV(exs, "1d", barStartMS, timeMS, 0, false)
+			if err != nil {
+				log.Warn("get volume failed", zap.String("pair", pair), zap.Error(err))
+				continue
+			}
+
+			// 计算成交量
+			vols := make([]float64, len(bars))
+			for i, bar := range bars {
+				vols[i] = bar.Close * bar.Volume
+			}
+
+			// 构建PairSample
+			sample := &PairSample{
+				Offset:    offset,
+				Pair:      pair,
+				Code:      baseCode,
+				Price:     mktSlice.Price,
+				MarketCap: mktSlice.MarketCap,
+				Vols:      vols,
+			}
+
+			timeMap[pair] = sample
+		}
+
+		if len(timeMap) > 0 {
+			res.Data[timeMS] = timeMap
+			res.Times = append(res.Times, timeMS)
+		}
+	}
+
+	if len(badCoins) > 0 {
+		log.Warn("unknown coins", zap.String("v", utils2.MapToStr(badCoins, false, 0)))
+	}
+	if len(skipCoins) > 0 {
+		log.Warn("skip coins", zap.String("v", utils2.MapToStr(skipCoins, false, 0)))
+	}
+
+	// 保存结果
+	name := fmt.Sprintf("facHis_%dM.gob", monNum)
+	outPath := filepath.Join(config.GetDataDir(), name)
+	return utils2.EncodeGob(outPath, res)
+}
+
+func TestFactors(args []string) error {
+	parser := flag.NewFlagSet("", flag.ExitOnError)
+	var monNum, outNum, offNum int
+	var facStr, outBy string
+	parser.IntVar(&monNum, "mon", 2, "month for period")
+	parser.IntVar(&outNum, "out", 3, "output group num")
+	parser.IntVar(&offNum, "off", 0, "skip group num in head")
+	parser.StringVar(&facStr, "fac", "", "factors to test")
+	parser.StringVar(&outBy, "outBy", "", "calc output score by")
+	err_ := parser.Parse(args)
+	if err_ != nil {
+		return err_
+	}
+	facArr := utils2.SplitSolid(facStr, ",", true)
+	if len(facArr) == 0 {
+		return errors.New("-fac is required")
+	}
+	dayNum := monNum * 30
+	fac := &FacHis{Pairs: make(map[string]*ItemReturns), Data: make(map[int64]map[string]*PairSample)}
+	facPath := filepath.Join(config.GetDataDir(), fmt.Sprintf("facHis_%dM.gob", monNum))
+	err := utils2.DecodeGobFile(facPath, fac)
+	if err != nil {
+		return err
+	}
+	groupMeas := make(map[string][]*GpState)
+	for i, stampMS := range fac.Times {
+		if i <= offNum {
+			continue
+		}
+		pairSamples := fac.Data[stampMS]
+		items := make([]*FacState, 0)
+		for pair, smp := range pairSamples {
+			ret := fac.Pairs[pair]
+			items = append(items, &FacState{
+				Ret:    ret,
+				Sample: smp,
+				Groups: make(map[string]string),
+			})
+		}
+		// 计算每个采样所属的因子分组
+		for _, factor := range facArr {
+			var pos []int
+			var tags []string
+			if factor == "marketCap" {
+				pos, tags = facMarketCap(items)
+			} else if factor == "vol1M" {
+				// 优于vol2w和marketCap
+				pos, tags = facVol1M(items)
+			} else if factor == "volStd" {
+				// 成交量波动较低的
+				pos, tags = facVolStd(items)
+			} else if factor == "mont1" {
+				// 3M下，跟mont2不相上下
+				pos, tags = facMont1(items, dayNum)
+			} else if factor == "mont2" {
+				pos, tags = facMont2(items, dayNum)
+			} else if factor == "mont1y" {
+				pos, tags = facMont1Y(items, dayNum)
+			} else if factor == "sharpe1y" {
+				pos, tags = facSharpe1Y(items, dayNum)
+			} else if factor == "score1y" {
+				pos, tags = facScore1Y(items, dayNum)
+			} else {
+				return errors.New("unknown factor: " + factor)
+			}
+			if len(pos)+1 != len(tags) {
+				return errors.New("invalid factor: " + factor)
+			}
+			start := 0
+			for i, end := range pos {
+				tag := tags[i]
+				for j := start; j < end; j++ {
+					items[j].Groups[factor] = tag
+				}
+				start = end
+			}
+			tag := tags[len(tags)-1]
+			for j := start; j < len(items); j++ {
+				items[j].Groups[factor] = tag
+			}
+		}
+		// 组合因子分组
+		groups := make(map[string][]*FacState)
+		for _, sta := range items {
+			var b strings.Builder
+			for _, f := range facArr {
+				b.WriteString(sta.Groups[f] + "+")
+			}
+			sta.Label = strings.TrimRight(b.String(), "+")
+			gpItems, _ := groups[sta.Label]
+			groups[sta.Label] = append(gpItems, sta)
+			end := sta.Sample.Offset + dayNum
+			if end > len(sta.Ret.Arr) {
+				end = len(sta.Ret.Arr)
+			}
+			// 计算未来分数，并进行分组打分
+			futures := sta.Ret.Arr[sta.Sample.Offset:end]
+			if outBy == "profit" {
+				sta.OutScore = floats.Sum(futures)
+			} else if outBy == "sharpe" {
+				sta.OutScore, err_ = utils2.SharpeRatioBy(futures, 0.02, 365, true)
+				if err_ != nil {
+					return err_
+				}
+			} else if outBy == "smart" || outBy == "" {
+				sharpe, err_ := utils2.SharpeRatioBy(futures, 0.02, 365, true)
+				if err_ != nil {
+					return err_
+				}
+				profit := floats.Sum(futures)
+				sta.OutScore = math.Log2(profit) * sharpe
+			} else {
+				return errors.New("unknown outBy: " + outBy)
+			}
+		}
+		// 按输出分数降序
+		sort.Slice(items, func(i, j int) bool {
+			return items[i].OutScore < items[j].OutScore
+		})
+		for i, it := range items {
+			it.OutID = i
+		}
+		// 计算每个目标块应包含的FacState数量
+		blockNum := int(math.Ceil(float64(len(items)) / float64(outNum)))
+		for key, gpList := range groups {
+			// 遍历分组中的每个FacState,根据其OutID确定所属块
+			blocks, ok := groupMeas[key]
+			if !ok {
+				blocks = make([]*GpState, outNum)
+				for i := 0; i < outNum; i++ {
+					blocks[i] = &GpState{}
+				}
+				groupMeas[key] = blocks
+			}
+			for _, state := range gpList {
+				blockID := state.OutID / blockNum // 确定目标块ID
+				if blockID >= outNum {
+					blockID = outNum - 1 // 处理边界情况
+				}
+
+				// 更新该块的统计信息
+				block := blocks[blockID]
+				block.count++
+				block.sumScore += utils2.NanInfTo(state.OutScore, 0)
+			}
+		}
+	}
+
+	countDsList := make([]*opt.ChartDs, len(groupMeas)) // 用于绘制数量分布图
+	scoreDsList := make([]*opt.ChartDs, len(groupMeas)) // 用于绘制平均分数图
+	// 生成x轴标签
+	xLabels := make([]string, outNum)
+	for i := 0; i < outNum; i++ {
+		xLabels[i] = fmt.Sprintf("Block%d", i+1)
+	}
+
+	keys := utils2.KeysOfMap(groupMeas)
+	slices.Sort(keys)
+	for i, key := range keys {
+		counts := make([]float64, outNum)
+		for j := 0; j < outNum; j++ {
+			counts[j] = groupMeas[key][j].count
+		}
+		countDsList[i] = &opt.ChartDs{
+			Label: key,
+			Data:  counts,
+		}
+		scores := make([]float64, outNum)
+		for j := 0; j < outNum; j++ {
+			bk := groupMeas[key][j]
+			scores[j] = bk.sumScore / bk.count
+		}
+		scoreDsList[i] = &opt.ChartDs{
+			Label: key,
+			Data:  scores,
+		}
+	}
+
+	facNames := strings.Join(facArr, "+")
+
+	// 生成数量分布折线图
+	countPath := filepath.Join(config.GetDataDir(), fmt.Sprintf("fac_count_%dM.html", monNum))
+	err = opt.DumpChart(countPath, "Distribution: "+facNames, xLabels, 5, nil, countDsList)
+	if err != nil {
+		return err
+	}
+
+	// 生成平均分数折线图
+	scorePath := filepath.Join(config.GetDataDir(), fmt.Sprintf("fac_score_%dM.html", monNum))
+	err = opt.DumpChart(scorePath, "Average Scores: "+facNames, xLabels, 5, nil, scoreDsList)
+	if err != nil {
+		return err
+	}
+	log.Info(fmt.Sprintf("generate in BanDataDir: fac_score_%dM.html fac_count_%dM.html", monNum, monNum))
+	return nil
+}
+
+func facMarketCap(items []*FacState) ([]int, []string) {
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Sample.MarketCap - a.Sample.MarketCap) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facVol1M(items []*FacState) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, len(it.Sample.Vols)-30)
+		it.Tmp = floats.Sum(it.Sample.Vols[start:])
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facVolStd(items []*FacState) ([]int, []string) {
+	for _, it := range items {
+		arr := it.Sample.Vols
+		data := make([]float64, 0, len(arr))
+		for i, v := range arr[1:] {
+			data = append(data, v/arr[i])
+		}
+		it.Tmp = utils2.StdDevVolatility(data, 1)
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facMont1(items []*FacState, unitDays int) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, it.Sample.Offset-unitDays)
+		it.Tmp = floats.Sum(it.Ret.Arr[start:it.Sample.Offset])
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facMont2(items []*FacState, unitDays int) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, it.Sample.Offset-unitDays*2)
+		it.Tmp = floats.Sum(it.Ret.Arr[start:it.Sample.Offset])
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facMont1Y(items []*FacState, unitDays int) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, it.Sample.Offset-unitDays*6)
+		it.Tmp = floats.Sum(it.Ret.Arr[start:it.Sample.Offset])
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facSharpe1Y(items []*FacState, unitDays int) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, it.Sample.Offset-unitDays*6)
+		arr := it.Ret.Arr[start:it.Sample.Offset]
+		sharpe, err := utils2.SharpeRatioBy(arr, 0.02, 365, true)
+		if err != nil {
+			log.Info("calc sharpe fail", zap.Error(err))
+		}
+		it.Tmp = sharpe
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}
+
+func facScore1Y(items []*FacState, unitDays int) ([]int, []string) {
+	for _, it := range items {
+		start := max(0, it.Sample.Offset-unitDays*6)
+		arr := it.Ret.Arr[start:it.Sample.Offset]
+		sharpe, err_ := utils2.SharpeRatioBy(arr, 0.02, 365, true)
+		if err_ != nil {
+			log.Error("calc sharpe fail", zap.Error(err_))
+		}
+		profit := floats.Sum(arr)
+		it.Tmp = math.Log2(profit) * sharpe
+	}
+	slices.SortFunc(items, func(a, b *FacState) int {
+		return int((b.Tmp - a.Tmp) / 1000)
+	})
+	totalNum := float64(len(items))
+	bigNum := int(totalNum * 0.3)
+	midEnd := int(totalNum*0.4) + bigNum
+	return []int{bigNum, midEnd}, []string{"big", "mid", "sml"}
+}