siat 2.0.19__py3-none-any.whl → 2.1.5__py3-none-any.whl

siat/stock_china.py

@@ -20,54 +20,88 @@ from siat.security_prices import *
 #==============================================================================
 
 if __name__=='__main__':
-    ticker='600519'
+    ticker='600519.Ss'
 
-def get_money_flowin(ticker):
+    dfp=get_money_flowin(ticker)
+    
+    end='2023-6-15'
+    dfp=get_money_flowin(ticker,end)
+
+def get_money_flowin(ticker,end='latest'):
     """
     功能：抓取个股近一百个交易日的资金净流入情况，以及大盘指数的情况
-    ticker：个股代码，不带后缀
+    ticker：个股代码，带后缀
     标准化方法：原始数据
+    注意：目前仅支持沪深股市
     """
+    ticker1=ticker.upper()[:6]
+    exch=ticker.upper()[7:9]
+    
     import akshare as ak
     import pandas as pd
     
     #判断沪深市场
-    l1=ticker[0]; market='sh'
-    if l1 in ['0','2','3']: market='sz'
-    #深市股票以0/2/3开头，沪市以6/9开头
-
+    if exch=='':
+        l1=ticker[0]; market='sh'
+        if l1 in ['0','2','3']: market='sz'
+        #深市股票以0/2/3开头，沪市以6/9开头
+    else:
+        if exch=='SS':
+            market='sh'
+        elif exch=='SZ':
+            market='sz'
+        else:
+            print("  #Warning(get_money_flowin): currently only support Shanghai/Shenzhen stock exchanges")
+            return None
+    
     #获得个股资金流动明细
     try:
-        df = ak.stock_individual_fund_flow(stock=ticker, market=market)
+        df = ak.stock_individual_fund_flow(stock=ticker1, market=market)
     except:
-        print("#Error(predict_price_direction): stock code not found for",ticker)
-        return
+        print("  #Error(get_money_flowin): money flow info unavailable for",ticker)
+        return None
 
     df['ticker']=ticker
+
+    df['Date']=df['日期'].apply(lambda x: pd.to_datetime(x))  #不带时区的日期
+    df.set_index('Date',inplace=True)
     df['date']=df['日期']
+    
+    df['Close']=df['收盘价'].apply(lambda x: float(x))
+    df['Change%']=df['涨跌幅'].apply(lambda x: float(x))
+    
     #类型转换
     df['netFlowInAmount_main']=df['主力净流入-净额'].apply(lambda x: float(x))
     df['netFlowInAmount_small']=df['小单净流入-净额'].apply(lambda x: float(x))
     df['netFlowInAmount_mid']=df['中单净流入-净额'].apply(lambda x: float(x))
     df['netFlowInAmount_big']=df['大单净流入-净额'].apply(lambda x: float(x))
     df['netFlowInAmount_super']=df['超大单净流入-净额'].apply(lambda x: float(x))
+    
+    # 总净流入金额：可正可负
     df['netFlowInAmount']=df['netFlowInAmount_main']+df['netFlowInAmount_small']+ \
-        df['netFlowInAmount_mid']+df['netFlowInAmount_big']+df['netFlowInAmount_super']
+                          df['netFlowInAmount_mid']+df['netFlowInAmount_big']+ \
+                          df['netFlowInAmount_super']
 
     df['netFlowInRatio%_main']=df['主力净流入-净占比'].apply(lambda x: float(x))
     df['netFlowInRatio%_small']=df['小单净流入-净占比'].apply(lambda x: float(x))
     df['netFlowInRatio%_mid']=df['中单净流入-净占比'].apply(lambda x: float(x))
     df['netFlowInRatio%_big']=df['大单净流入-净占比'].apply(lambda x: float(x))
     df['netFlowInRatio%_super']=df['超大单净流入-净占比'].apply(lambda x: float(x))
-    
-    #重要：删除有缺失值的记录，确保未收盘时能预测当天的收盘价涨跌方向
-    df.dropna(inplace=True)
-
-    df['Close']=df['收盘价'].apply(lambda x: float(x))
-    df['Change%']=df['涨跌幅'].apply(lambda x: float(x))
 
-    df['Date']=df['日期'].apply(lambda x: pd.to_datetime(x))  #不带时区的日期
-    df.set_index('Date',inplace=True)
+    #重要：处理有缺失值的记录，确保未收盘时能预测当天的收盘价涨跌方向
+    #df.dropna(inplace=True)
+    df.fillna(0,inplace=True)
+    
+    # 对数量级巨大的金额项进行对数处理，避免其对数量级小的项形成数量级压制
+    amtColList=['netFlowInAmount_main','netFlowInAmount_small','netFlowInAmount_mid', \
+                'netFlowInAmount_big','netFlowInAmount_super','netFlowInAmount']
+    import math
+    for a in amtColList:
+        # 取对数
+        df[a+'_ln']=df[a].apply(lambda x: math.log(x) if x>0 else -math.log(-x) if x<0 else 0)
+    
+    # 删除原有金额项目
+    df.drop(amtColList,axis=1,inplace=True)
     
     #去掉不用的字段
     dfdroplist=['主力净流入-净额','小单净流入-净额','中单净流入-净额','大单净流入-净额', \
@@ -76,36 +110,47 @@ def get_money_flowin(ticker):
                 '收盘价','涨跌幅','日期']
     df.drop(labels=dfdroplist,axis=1,inplace=True)
     
-    #获得大盘指数
-    dpindex="sh000001"  #上证综合指数
-    if market == 'sz': dpindex="sz399001"   #深圳成分指数
-    dp=ak.stock_zh_index_daily(symbol=dpindex)
-    dp['Date']=dp.index
-    dp['Date']=dp['Date'].apply(lambda x: x.replace(tzinfo=None))   #去掉时区信息
-    dp.set_index('Date',inplace=True)
-    
-    #去掉不用的字段
-    dpdroplist=['open','high','low']
-    dp.drop(labels=dpdroplist,axis=1,inplace=True)
-    dp.rename(columns={'close':'dpClose','volume':'dpVolume'}, inplace = True)
-    
-    #合并大盘指数：索引日期均不带时区，否则出错
-    dfp=pd.merge(df,dp,how='left',left_index=True,right_index=True)  
-    
-    """
-    #取得标签/特征向量
-    ydf=dfp[['Close','Change%']]
-    X=dfp.drop(labels=['date','Close','Change%'],axis=1)
-    
-    scaler_X=preproc(X,preproctype=preproctype)
-    scaler_dfp=pd.merge(scaler_X,ydf,how='left',left_index=True,right_index=True) 
-    return scaler_dfp
-    """
+    df.sort_index(ascending=True,inplace=True)
+    fromdate=df['date'].values[0]
+    todate=df['date'].values[-1]
+    
+    #获得大盘指数和交易量
+    dpindex="000001.SS"  #上证综合指数
+    if market == 'sz': dpindex="399001.SZ"   #深圳成分指数
+    df_dp_tmp=get_price(dpindex,fromdate,todate)
+    
+    df_dp_tmp['Volume_mkt']=df_dp_tmp['Volume'].apply(lambda x: math.log(x))
+    df_dp_tmp['Close_mkt']=df_dp_tmp['Close']
+    df_dp=df_dp_tmp[['Volume_mkt','Close_mkt']]
+    
+    # 获得股票交易量
+    df_stk_tmp=get_price(ticker,fromdate,todate)
+    df_stk_tmp['Volume_ln']=df_stk_tmp['Volume'].apply(lambda x: math.log(x))
+    df_stk=df_stk_tmp[['Open','High','Low','Adj Close','Volume_ln']]
+
+    # 合并
+    df_stk_mkt=pd.merge(df_stk,df_dp,how='left',left_index=True,right_index=True) 
+    
+    dfp_tmp=pd.merge(df,df_stk_mkt,how='left',left_index=True,right_index=True)
+    newColList=['date','Close','Change%','Adj Close','Open','High','Low','Volume_ln', \
+                'netFlowInRatio%_main','netFlowInRatio%_small','netFlowInRatio%_mid', \
+                'netFlowInRatio%_big','netFlowInRatio%_super', \
+                'netFlowInAmount_main_ln','netFlowInAmount_small_ln','netFlowInAmount_mid_ln', \
+                'netFlowInAmount_big_ln','netFlowInAmount_super_ln', 'netFlowInAmount_ln', \
+                'Close_mkt','Volume_mkt']
+    dfp=dfp_tmp[newColList]
+    
+    if end=='latest':
+        dfp2=dfp
+    else:
+        jieguo,end2=check_date2(end)
+        if not jieguo:
+            dfp2=dfp
+        else:
+            dfp2=dfp[dfp['date'] <= end2]
     
-    return dfp
+    return dfp2
 
-if __name__=='__main__':
-    dfp=get_money_flowin('600519')
 
 #==============================================================================
 # 对特征数据进行预处理
@@ -169,9 +214,13 @@ if __name__=='__main__':
 #==============================================================================
 if __name__=='__main__':
     ndays=1
-    preCumTimes=1
+    preCumTimes=5
+    
+    dfp=get_money_flowin('600519.SS')
+    
+    X,ydf,X_new=make_sample(dfp,ndays=1)
 
-def make_sample(dfp,ndays=1,preCumTimes=1):
+def make_sample(dfp,ndays=1,preCumTimes=5):
     """
     功能：构造适合机器学习的样本
     ndays：预测未来几个交易日
@@ -183,55 +232,68 @@ def make_sample(dfp,ndays=1,preCumTimes=1):
     preDays=ndays * preCumTimes
     
     #构造过去一段时间资金净流入累加值
-    dfp['netFlowInAmtCum_main']=dfp['netFlowInAmount_main'].rolling(window=preDays,min_periods=1).sum()
-    dfp['netFlowInAmtCum_small']=dfp['netFlowInAmount_small'].rolling(window=preDays,min_periods=1).sum()
-    dfp['netFlowInAmtCum_mid']=dfp['netFlowInAmount_mid'].rolling(window=preDays,min_periods=1).sum()
-    dfp['netFlowInAmtCum_big']=dfp['netFlowInAmount_big'].rolling(window=preDays,min_periods=1).sum()
-    dfp['netFlowInAmtCum_super']=dfp['netFlowInAmount_super'].rolling(window=preDays,min_periods=1).sum()
-    dfp['netFlowInAmtCum']=dfp['netFlowInAmount'].rolling(window=preDays,min_periods=1).sum()
+    amtColList=[]
+    colList=list(dfp)
+    for c in colList:
+        if 'Amount' in c:
+            amtColList=amtColList+[c]
+    
+    for c in amtColList:
+        dfp[c+'_cum']=dfp[c].rolling(window=preDays,min_periods=1).sum()
     
     #构造过去一段时间资金净流入比例均值
-    dfp['netFlowInRatioAvg%_main']=dfp['netFlowInRatio%_main'].rolling(window=preDays,min_periods=1).mean()    
-    dfp['netFlowInRatioAvg%_small']=dfp['netFlowInRatio%_small'].rolling(window=preDays,min_periods=1).mean() 
-    dfp['netFlowInRatioAvg%_mid']=dfp['netFlowInRatio%_mid'].rolling(window=preDays,min_periods=1).mean() 
-    dfp['netFlowInRatioAvg%_big']=dfp['netFlowInRatio%_big'].rolling(window=preDays,min_periods=1).mean() 
-    dfp['netFlowInRatioAvg%_super']=dfp['netFlowInRatio%_super'].rolling(window=preDays,min_periods=1).mean() 
-
+    ratioColList=[]
+    for c in colList:
+        if 'Ratio' in c:
+            ratioColList=ratioColList+[c]
+    
+    for c in ratioColList:
+        dfp[c+'_avg']=dfp[c].rolling(window=preDays,min_periods=1).mean()
+    
     #构造过去一段时间大盘指数的均值和标准差
-    dfp['dpCloseAvg']=dfp['dpClose'].rolling(window=preDays,min_periods=1).mean()
-    #dfp['dpCloseStd']=dfp['dpClose'].rolling(window=preDays,min_periods=1).std()
-    dfp['dpVolumeAvg']=dfp['dpVolume'].rolling(window=preDays,min_periods=1).mean()
-    #dfp['dpVolumeStd']=dfp['dpVolume'].rolling(window=preDays,min_periods=1).std()   
+    mktColList=['Close_mkt','Volume_mkt']
+    for c in mktColList:
+        dfp[c+'_avg']=dfp[c].rolling(window=preDays,min_periods=1).mean()
+        dfp[c+'_std']=dfp[c].rolling(window=preDays,min_periods=1).std()
     
     #重要：去掉前几行，此处位置敏感
-    dfp.dropna(inplace=True)
-    
-    #添加未来更多天的股价信息
-    ylist=[]
-    for nd in list(range(1,ndays+1)):
-        dfp['Close_next'+str(nd)]=dfp['Close'].shift(-nd)
-        ylist=ylist+['Close_next'+str(nd)]
-        dfp['Change%_next'+str(nd)]=dfp['Change%'].shift(-nd)
-        ylist=ylist+['Change%_next'+str(nd)]
-    
-    X = dfp[[
-         'netFlowInAmount_main','netFlowInAmount_small','netFlowInAmount_mid', \
-         'netFlowInAmount_big','netFlowInAmount_super','netFlowInAmount', \
-         
-         'netFlowInAmtCum_main','netFlowInAmtCum_small','netFlowInAmtCum_mid', \
-         'netFlowInAmtCum_big','netFlowInAmtCum_super','netFlowInAmtCum', \
-         
-         'netFlowInRatio%_main','netFlowInRatio%_small','netFlowInRatio%_mid', \
-         'netFlowInRatio%_big','netFlowInRatio%_super',
-         
-         'netFlowInRatioAvg%_main','netFlowInRatioAvg%_small','netFlowInRatioAvg%_mid', \
-         'netFlowInRatioAvg%_big','netFlowInRatioAvg%_super',
-         
-         'dpClose','dpCloseAvg','dpVolume','dpVolumeAvg']]
-    
-    ydf = dfp[ylist]
-    
-    return X,ydf
+    dfp1=dfp.dropna()
+    if len(dfp1)==0:
+        print("  #Error(make_sample): dropna caused empty dataframe, process stopped")
+        return None,None
+    
+    #按照ndays滚动
+    newColList=list(dfp1)
+    newColList.remove('date')
+    dfp2=dfp1[newColList]
+    for c in newColList:
+        dfp2[c+'_roll']=dfp2[c].rolling(window=ndays,min_periods=1).mean()
+    
+    newColList2=list(dfp2)
+    newColList3=[]
+    for c in newColList2:
+        if '_roll' in c:
+            newColList3=newColList3+[c]
+    newColList3=newColList3+['Close','Change%']
+    dfp3=dfp2[newColList3]
+    
+    #添加未来一个单位(ndays)的股价信息
+    dfp3['Close_next']=dfp3['Close'].shift(-1)
+    dfp3['Change%_next']=dfp3['Change%'].shift(-1)
+    ylist=['Close_next','Change%_next']
+
+    #供训练用的数据集
+    XCollist=list(dfp3)
+    for c in ylist:
+        XCollist.remove(c)
+    dfp4=dfp3.dropna()
+    X = dfp4[XCollist]
+    ydf = dfp4[ylist]    
+    
+    # X_new
+    X_new = dfp3.tail(1)[XCollist]
+    
+    return X,ydf,X_new
 
 #==============================================================================
 # 训练模型，获得最优模型参数，进行预测
@@ -254,6 +316,8 @@ def train_predict_knn(X,ydf,noday=1,y='Close', \
     ydf：标签矩阵
     nodays：预测未来第几天
     y：标签，默认'Close'为股价，'Change%'为涨跌幅，'Direction'为涨跌方向
+    
+    未用！
     """
     ylist=['Close','Change%','Direction']
     if not (y in ylist):
@@ -332,6 +396,8 @@ def train_predict_knn(X,ydf,noday=1,y='Close', \
     if votes > len(r2): votes=len(r2)
     r2head=r2.head(votes)    
     
+    # 未完
+    
 #==============================================================================
 # 训练，获得最优模型参数
 #==============================================================================
@@ -347,6 +413,8 @@ def training_knn_clf(scaler_X,ydf,ndays=1,max_neighbors=10,max_p=6,cv=5,rs=0):
     功能：对(X,y)
     scaler_X: 特征矩阵
     y：标签矩阵
+    
+    未用！
     '''
     
     #获得分类变量y
@@ -397,71 +465,61 @@ def training_knn_clf(scaler_X,ydf,ndays=1,max_neighbors=10,max_p=6,cv=5,rs=0):
 # Forecasting stock price directions by money flow in/out, using knn
 #==============================================================================
 if __name__=='__main__':
-    ticker='600519'
+    ticker='600519.SS'
+    ticker='000723.SZ'
+    
     ndays=1
-    market='sh'
-    diff=0.03
+    min_score=0.9
+    diff=0.01
     votes=100
     max_neighbours=10
     max_RS=10
+    printout=True
+    
+    df=get_money_flowin(ticker,end='2023-6-15')
+    decision,known_close,known_day=price_direction_knn(ticker,df,ndays=1)
 
-def price_direction_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neighbours=10,max_RS=10,printout=True):
+def price_direction_knn(ticker,df,ndays=1,diff=0.01,min_score=0.9,votes=100,max_neighbours=10,max_RS=10,printout=True):
 
     """
     功能：基于个股资金流动预测次日股票涨跌方向，涨或跌
     ticker：股票代码，无后缀
     df：个股资金净流入
-    dp：大盘信息
     ndays：预测几天后的股价涨跌方向，默认1天
-    market：sh-沪市，sz-深市
-    diff：泛化精度，越小越好，默认0.03
-    votes：软表决票数，默认100
+    diff：泛化精度，越小越好
+    min_score：最小测试分数
+    votes：软表决票数
     max_neighbours：最大邻居个数
     max_RS：最大随机数种子
     """
     import pandas as pd
     
-    #构造标签
-    df['nextClose']=df['Close'].shift(-ndays)
-    df['nextChange%']=df['Change%'].shift(-ndays)
-    df['nextDirection']=df['nextChange%'].apply(lambda x: 1 if float(x) > 0 else -1)
-    
-    #构造特征
-    df['netFlowInChg_main']=df['netFlowInAmount_main'] - df['netFlowInAmount_main'].shift(-ndays)
-    df['netFlowInChg_small']=df['netFlowInAmount_small'] - df['netFlowInAmount_small'].shift(-ndays)
-    df['netFlowInChg_mid']=df['netFlowInAmount_mid'] - df['netFlowInAmount_mid'].shift(-ndays)
-    df['netFlowInChg_big']=df['netFlowInAmount_big'] - df['netFlowInAmount_big'].shift(-ndays)
-    df['netFlowInChg_super']=df['netFlowInAmount_super'] - df['netFlowInAmount_super'].shift(-ndays)
-    df['netFlowInChg']=df['netFlowInAmount'] - df['netFlowInAmount'].shift(-ndays)
-    
-    df['netFlowInRatio%Chg_main']=df['netFlowInRatio%_main'] - df['netFlowInRatio%_main'].shift(-ndays)
-    df['netFlowInRatio%Chg_small']=df['netFlowInRatio%_small'] - df['netFlowInRatio%_small'].shift(-ndays)
-    df['netFlowInRatio%Chg_mid']=df['netFlowInRatio%_mid'] - df['netFlowInRatio%_mid'].shift(-ndays)
-    df['netFlowInRatio%Chg_big']=df['netFlowInRatio%_big'] - df['netFlowInRatio%_big'].shift(-ndays)
-    df['netFlowInRatio%Chg_super']=df['netFlowInRatio%_super'] - df['netFlowInRatio%_super'].shift(-ndays)
-
-    df['dpCloseChg']=df['dpClose'] - df['dpClose'].shift(-ndays)
-    df['dpVolumeChg']=df['dpVolume'] - df['dpVolume'].shift(-ndays)
-
-    df2=df[['date','netFlowInChg_main',
-       'netFlowInChg_small','netFlowInChg_mid','netFlowInChg_big', \
-       'netFlowInChg_super','netFlowInChg','netFlowInRatio%Chg_main','netFlowInRatio%Chg_small', \
-       'netFlowInRatio%Chg_mid','netFlowInRatio%Chg_big','netFlowInRatio%Chg_super', \
-       'Close','Change%','dpCloseChg','dpVolumeChg','nextClose','nextChange%','nextDirection']]
-
-    #记录最新指标，用于预测次日涨跌
-    x_last=df2.copy().tail(1)
-    today=x_last['date'].values[0]
-    today_close=x_last['Close'].values[0]
-    x_last.drop(labels=['date','nextClose', 'nextChange%', 'nextDirection'],axis=1,inplace=True)
-    X_new = x_last.head(1).values
-
-    #建立样本：特征序列
-    df2.dropna(inplace=True)
-    X=df2.drop(labels=['date','nextClose', 'nextChange%', 'nextDirection'],axis=1)
-
+    # 判断是否周末无交易免预测
+    known_day=df.tail(1)['date'].values[0]
+    
+    tdate=date_adjust(known_day, adjust=ndays)
+    tdate_pd=pd.to_datetime(tdate)
+    tdate_wd=tdate_pd.weekday()
+    if tdate_wd in [5,6]:
+        print("  #Warning: after",ndays,"day(s) is",tdate,"(weekend), no trading")
+        decision='~'
+        known_close=df.tail(1)['Close'].values[0]
+        
+        return decision,known_close,known_day
+    
+    #构造样本：标签ydf，特征矩阵X，预测X_new
+    X,ydf,X_new=make_sample(df,ndays=ndays)
+    
+    #X_new1=X_new.head(1).values
+    known_day_np=X_new.index.values[0]
+    known_day_pd=pd.to_datetime(known_day_np)    
+    known_day=known_day_pd.strftime("%Y-%m-%d")
+    known_close=X_new['Close'].values[0]
+    
+    ydf['nextDirection']=ydf['Change%_next'].apply(lambda x: 1 if x>0 else -1 if x <0 else 0)
+    
     #建立样本：标签序列
-    y1=df2['nextDirection'] #二分类
+    y1=ydf['nextDirection'] #二分类
     #y2=df2['nextChange%']   #回归
     #y3=df2['nextClose']     #回归
 
@@ -480,17 +538,18 @@ def price_direction_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_
     mlist4=['cityblock','euclidean','minkowski','cosine']
     mlist=mlist1+mlist2+mlist3+mlist4
     rslist=list(range(0,max_RS+1))
+    
     results=pd.DataFrame(columns=('spread','train_score','test_score', \
                                   'neighbours','weight','metric','random','pred'))
     print('\nSearching for best parameters of knn model in',ndays,'trading days ...')
-    print('  Progress: 0%, ',end='')
+    print('  Progress: 0% ',end='')
     for n in nlist:
         for w in wlist:
             for m in mlist:
                 for rs in rslist:    
                     knn1=KNeighborsClassifier(n_neighbors=n,weights=w,metric=m,n_jobs=-1)
                     X_train,X_test,y_train,y_test=train_test_split(X,y1,random_state=rs)
-                    knn1.fit(X_train, y_train)
+                    tmp=knn1.fit(X_train, y_train) #调试时去掉tmp=可跟踪模型参数
                     train_score=round(knn1.score(X_train, y_train),3)
                     test_score=round(knn1.score(X_test, y_test),3)
                     prediction=knn1.predict(X_new)[0]
@@ -500,65 +559,145 @@ def price_direction_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_
                                    'test_score':test_score,'neighbours':n, \
                                    'weight':w,'metric':m,'random':rs,'pred':prediction})
                     results=results.append(row,ignore_index=True)
-        print(int(n/n_num*100),'\b%, ',end='')
+        print(int(n/n_num*100),'\b% ',end='')
     print('done.') 
     
-    #去掉严重过拟合的结果           
-    r0=results[results['train_score'] < 1]
-    #去掉训练集、测试集分数不过半的模型    
-    r0=r0[r0['train_score'] > min_score]
-    r0=r0[r0['test_score'] > min_score]
+    
+    # 过滤训练/测试分数差的结果
+    r0=results[(results['train_score']>=min_score) & (results['test_score']>=min_score)]
+    # 避免min_score设置得太高导致无结果，或者数量太多
+    r0_len=len(r0)
+    #if r0_len==0 or r0_len > votes:
+    if r0_len==0:
+        train_score_max=results['train_score'].max()
+        test_score_max=results['test_score'].max()
+        min_score_new=min(train_score_max,test_score_max)
+        r0=results[(results['train_score']>=min_score_new) & (results['test_score']>=min_score_new)]
+        
+        if len(r0)==0:
+            spread_quantile=results['spread'].quantile(q=0.01)
+            r0_spread=results[(results['spread']<spread_quantile)]
+            if len(r0_spread)==0:
+                r0_spread=results[(results['spread']<=spread_quantile)]
+
+            test_score_quantile=r0_spread['test_score'].quantile(q=0.99)
+            r0=r0_spread[(r0_spread['test_score']>test_score_quantile)]
+            if len(r0)==0:
+                r0=r0_spread[(r0_spread['test_score']>=test_score_quantile)]
+                
+            train_score_max=r0['train_score'].max()
+            test_score_max=r0['test_score'].max()
+            min_score_new=min(train_score_max,test_score_max)
+            
+        print("  #Warning: filtering parameter min_score has been adjusted to",min_score_new)
+    
     #去掉泛化效果差的结果
-    r0=r0[r0['spread'] < diff]  #限定泛化差距
-    #优先查看泛化效果最优的结果
-    r1=r0.sort_values(by=['spread','test_score'],ascending=[True,False])        
-    #优先查看测试分数最高的结果
-    r2=r0.sort_values(by=['test_score','spread'],ascending=[False,True])
-
-    if votes > len(r2): votes=len(r2)
-    r2head=r2.head(votes)
+    r1=r0[r0['spread'] <= diff]  #限定泛化差距
+    r1_len=len(r1)
+    #if r1_len==0 or r1_len>=votes:
+    if r1_len==0:
+        diff_new=r0['spread'].min()
+        r1=r0[r0['spread'] <= diff_new]
+        print("  #Warning: filtering parameter diff has been adjusted to",diff_new)
     
-    zhang=len(r2head[r2head['pred']==1])
-    die=len(r2head[r2head['pred']==-1])
     
-    decision='+'
-    if zhang >= die * 2.0: decision='2+'
-    if zhang >= die * 3.0: decision='3+'
+    """
+    # 首选测试效果好的
+    r0=results[(results['test_score']>=min_score)]
+    if len(r0)==0:
+        test_quantile=results['test_score'].quantile(q=0.99,interpolation='nearest')
+        r0=results[(results['test_score']>test_quantile)]
+        if len(r0)==0:
+            r0=results[(results['test_score']>=test_quantile)]
+    
+        print("  #Warning: filtering parameter min_score for testing has been adjusted to",test_quantile)
+    """
+
+    """
+    # 首选训练效果好的
+    r0=results[(results['train_score']>=min_score) & (results['train_score']<1.0)]
+    if len(r0)==0:
+        r0_train=results[(results['train_score']>=results['test_score']) & results['train_score']<1.0]
+        train_quantile=r0_train['train_score'].quantile(q=0.99,interpolation='nearest')
+        r0=r0_train[(r0_train['train_score']>train_quantile)]
+        if len(r0)==0:
+            r0=r0_train[(r0_train['train_score']>=train_quantile)]
+    
+        print("  #Warning: filtering parameter min_score for training has been adjusted to",train_quantile)
+    
+    # 再选泛化效果好的
+    r1=r0[(r0['spread']<=diff)]
+    if len(r1)==0:
+        spread_quantile=r0['spread'].quantile(q=0.05,interpolation='nearest')
+        r1=r0[(r0['spread']<spread_quantile)]
+        if len(r1)==0:
+            r1=r0[(r0['spread']<=spread_quantile)]
+    
+        print("  #Warning: filtering parameter diff has been adjusted to",spread_quantile)
+    """
     
-    if die > zhang: decision='-'
-    if die >= zhang * 2.0: decision='2-'
-    if die >= zhang * 3.0: decision='3-'
+    #优先查看泛化效果最优的结果：spread最小
+    votes=min(votes,len(r1))
+    r2=r1.sort_values(by=['spread','test_score'],ascending=[True,False]).head(votes)        
+    #优先查看测试分数最高的结果：test_score最大
+    r3=r2.sort_values(by=['test_score','spread'],ascending=[False,True])
+
+    r3head=r3
     
-    if abs(zhang-die)/((zhang+die)/2) < 0.05: decision='?'
+    zhang=len(r3head[r3head['pred']==1])
+    die=len(r3head[r3head['pred']==-1])
+    
+    decision='+'
+    decision_text='HIGHER'
+    if die != 0:
+        if zhang >= die * 2.0: decision='2+'
+        if zhang >= die * 3.0: decision='3+'
+    
+    if die > zhang: 
+        decision='-'
+        decision_text='LOWER'
+        if zhang != 0:
+            if die >= zhang * 2.0: decision='2-'
+            if die >= zhang * 3.0: decision='3-'
+    
+    #if abs(zhang-die)/((zhang+die)/2) < 0.05: decision='?'
+    if zhang==die: 
+        decision='='
+        decision_text='FLAT'
 
     if not printout: return decision,today_close,today
 
-    print("  Model poll for stock price after "+str(ndays)+" trading days: Higer("+str(zhang)+'), Lower('+str(die)+')')
-    print("Last close price: "+ticker+', '+str(today_close)+', '+str(today))
-    print("Prediction for stock price after "+str(ndays)+" trading day: "+decision)
-    return decision,today_close,today
+    print("  Model voting for stock price after "+str(ndays)+" trading days: Higher("+str(zhang)+'), Lower('+str(die)+')')
+    print("  "+codetranslate(ticker)+': previously closed '+str(known_close)+' @ '+str(known_day))
+    
+    ndate=date_adjust(known_day,adjust=ndays)
+    print("  Prediction to close at",decision_text,"price trend ("+decision+') @',ndate)
+    
+    return decision,known_close,known_day
 
-if __name__=='__main__':
-    df=price_direction_knn('600519',ndays=1,max_neighbours=5,max_RS=2)
     
 #==============================================================================
 if __name__=='__main__':
-    ticker='600519'
+    ticker='600519.SS'
     ndays=1
-    market='sh'
-    diff=0.03
+    diff=0.01
+    min_score=0.9
     votes=100
     max_neighbours=3
-    max_RS=2
+    max_RS=20
+    preproctype='0-1'
+    
+    df=forecast_direction_knn(ticker,ndays=1)
+    df=forecast_direction_knn(ticker,ndays=3)
 
-def forecast_direction_knn(ticker,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neighbours=10,max_RS=10,preproctype='0-1'):
+def forecast_direction_knn(ticker,ndays=1,diff=0.01,min_score=0.9,votes=100,max_neighbours=10,max_RS=20,preproctype='0-1',end='latest'):
 
     """
     功能：基于个股资金流动预测未来股票涨跌方向，涨或跌
     ticker：股票代码，无后缀
     ndays：预测几天后的股价涨跌方向，默认1天
-    market：sh-沪市，sz-深市
-    diff：泛化精度，越小越好，默认0.03
+    diff：泛化精度，越小越好
+    min_score：最小训练/学习分数
     votes：软表决票数，默认最大100
     max_neighbours：最大邻居个数，默认10个
     max_RS：最大随机数种子，默认最大为10
@@ -566,96 +705,98 @@ def forecast_direction_knn(ticker,ndays=1,diff=0.03,min_score=0.6,votes=100,max_
     print("\nStart forecasting, it may take great time, please wait ...")
     
     #抓取个股资金净流入情况df和大盘指数情况dp
-    df0,X,ydf=get_money_flowin(ticker)
-    scaler_X=preproc(X,preproctype=preproctype)
-    
-    #测试用
-    df=df0.copy()
+    df=get_money_flowin(ticker,end=end)
     
     #预测未来股价涨跌
     decisionlist=[]
     for nd in list(range(1,ndays+1)):
-        decision,today_close,today=price_direction_knn(ticker,df,ndays=nd, \
-            diff=diff,min_score=min_score,votes=votes,max_neighbours=max_neighbours,max_RS=max_RS)
+        decision,known_close,known_day=price_direction_knn(ticker,df,ndays=nd, \
+                                                       diff=diff, \
+                                                       min_score=min_score, \
+                                                       votes=votes, \
+                                                       max_neighbours=max_neighbours, \
+                                                       max_RS=max_RS)
         decisionlist=decisionlist+[decision]
 
-    print("\nStock information:",ticker,today_close,today)
-    print("Forecasting stock prices in next",ndays,"trading days: ",end='')
-    for i in decisionlist:
-        print(i,'\b ',end='')
-    print('\b.')
-    
-    return
+    print("\nStock information:",codetranslate(ticker),'\b, closed',known_close,'@',known_day)
+    for nd in list(range(1,ndays+1)):
+        ndate=date_adjust(known_day, adjust=nd)
+        print("Forecasting stock close price trend on",ndate,end=': ')
+        pred=decisionlist[nd-1]
+        if '-' in pred:
+            print("LOWER,",pred)
+        if '+' in pred:
+            print("HIGHER,",pred)
+        if '~' in pred:
+            print("market closed")            
+        if '=' in pred:
+            print("least different")  
+            
+    return decisionlist,known_close,known_day
 
-if __name__=='__main__':
-    df=forecast_direction_knn('600519',ndays=1,max_neighbours=5,max_RS=2)
 
 #==============================================================================
 # Forecasting stock prices by money flow in/out, using knn
 #==============================================================================
 
 if __name__=='__main__':
-    ticker='600519'
+    ticker='600519.SS'
+    ticker='605011.SS'
+    
     ndays=1
-    market='sh'
-    diff=0.03
+    diff=0.01
+    min_score=0.8
     votes=100
     max_neighbours=10
     max_RS=10
+    printout=True
+    
+    df=get_money_flowin(ticker,end='2023-6-15')
+    pred_result=price_price_knn(ticker,df,ndays=1)
+    pred_result=price_price_knn(ticker,df,ndays=3)
 
-def price_price_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neighbours=10,max_RS=10,printout=True):
-
+#def price_price_knn(ticker,df,ndays=1,diff=0.01,min_score=0.8,votes=100,max_neighbours=10,max_RS=20,printout=True):
+def price_price_knn(ticker,df,ndays=1,max_neighbours=10,max_RS=20,printout=True):
+    
     """
     功能：基于个股资金流动预测次日股票价格
     ticker：股票代码，无后缀
     df：个股资金净流入信息
-    dp：大盘信息
     ndays：预测几天后的股价涨跌方向，默认1天
-    market：sh-沪市，sz-深市
-    diff：泛化精度，越小越好，默认0.03
-    votes：软表决均值，默认100
+    diff：弃用。泛化精度，越小越好
+    min_score：弃用。最小训练/测试分数，越大越好
+    votes：弃用。软表决均值，默认100
     max_neighbours：最大邻居个数
     max_RS：最大随机数种子
     """
     import pandas as pd
+ 
+    # 判断是否周末无交易免预测
+    known_day=df.tail(1)['date'].values[0]
+    
+    tdate=date_adjust(known_day, adjust=ndays)
+    tdate_pd=pd.to_datetime(tdate)
+    tdate_wd=tdate_pd.weekday()
+    if tdate_wd in [5,6]:
+        print("  #Warning: after",ndays,"day(s) is",tdate,"(weekend), no trading")
+        decision=0
+        decision_score=0
+        known_close=df.tail(1)['Close'].values[0]
+        
+        return decision,decision_score,known_close,known_day   
+ 
+    #构造样本：标签ydf，特征矩阵X，预测X_new
+    X,ydf,X_new=make_sample(df,ndays=ndays)
     
-    #构造标签
-    df['nextClose']=df['Close'].shift(-ndays)
-    df['nextChange%']=df['Change%'].shift(-ndays)
-    df['nextDirection']=df['nextChange%'].apply(lambda x: 1 if float(x) > 0 else -1)
-    
-    #构造特征
-    df['netFlowInChg_main']=df['netFlowInAmount_main']/(df['netFlowInAmount_main'].shift(ndays))
-    df['netFlowInChg_small']=df['netFlowInAmount_small']/(df['netFlowInAmount_small'].shift(ndays))
-    df['netFlowInChg_mid']=df['netFlowInAmount_mid']/(df['netFlowInAmount_mid'].shift(ndays))
-    df['netFlowInChg_big']=df['netFlowInAmount_big']/(df['netFlowInAmount_big'].shift(ndays))
-    df['netFlowInChg_super']=df['netFlowInAmount_super']/(df['netFlowInAmount_super'].shift(ndays))
-    df['netFlowInChg']=df['netFlowInAmount']/(df['netFlowInAmount'].shift(ndays))
-
-    df['dpCloseChg']=df['dpClose']/(df['dpClose'].shift(ndays))
-    df['dpVolumeChg']=df['dpVolume']/(df['dpVolume'].shift(ndays))
-
-    df2=df[['date','netFlowInChg_main',
-       'netFlowInChg_small','netFlowInChg_mid','netFlowInChg_big', \
-       'netFlowInChg_super','netFlowInChg','netFlowInRatio%_main','netFlowInRatio%_small', \
-       'netFlowInRatio%_mid','netFlowInRatio%_big','netFlowInRatio%_super', \
-       'Close','Change%','dpCloseChg','dpVolumeChg','nextClose','nextChange%','nextDirection']]
-
-    #记录最新指标，用于预测次日涨跌
-    x_last=df2.copy().tail(1)
-    today=x_last['date'].values[0]
-    today_close=x_last['Close'].values[0]
-    x_last.drop(labels=['date','nextClose', 'nextChange%', 'nextDirection'],axis=1,inplace=True)
-    X_new = x_last.head(1).values
-
-    #建立样本：特征序列
-    df2.dropna(inplace=True)
-    X=df2.drop(labels=['date','nextClose', 'nextChange%', 'nextDirection'],axis=1)
+    known_day_np=X_new.index.values[0]
+    known_day_pd=pd.to_datetime(known_day_np)    
+    known_day=known_day_pd.strftime("%Y-%m-%d")
+    known_close=X_new['Close'].values[0]    
 
     #建立样本：标签序列
     #y1=df2['nextDirection'] #二分类
     #y2=df2['nextChange%']   #回归
-    y3=df2['nextClose']     #回归
+    y3=ydf['Close_next']      #回归
 
     #拆分训练集和测试集：y1
     from sklearn.model_selection import train_test_split
@@ -672,10 +813,11 @@ def price_price_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neig
     mlist4=['cityblock','euclidean','minkowski','cosine']
     mlist=mlist1+mlist2+mlist3+mlist4
     rslist=list(range(0,max_RS+1))
+    
     results=pd.DataFrame(columns=('spread','train_score','test_score', \
                                   'neighbours','weight','metric','random','pred'))
     print('\nSearching for best parameters of knn model in',ndays,'trading days ...')
-    print('  Progress: 0%, ',end='')
+    print('  Progress: 0% ',end='')
     for n in nlist:
         for w in wlist:
             for m in mlist:
@@ -683,121 +825,204 @@ def price_price_knn(ticker,df,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neig
                     try:
                         knn1=KNeighborsRegressor(n_neighbors=n,weights=w,metric=m,n_jobs=-1)
                         X_train,X_test,y_train,y_test=train_test_split(X,y3,random_state=rs)
-                        knn1.fit(X_train, y_train)
+                        tmp=knn1.fit(X_train, y_train)
                         train_score=round(knn1.score(X_train, y_train),3)
                         test_score=round(knn1.score(X_test, y_test),3)
                         prediction=knn1.predict(X_new)[0]
                     except:
-                        print("  #Bug: n=",n,"w=",w,"m=",m,"rs=",rs)
-                        break
+                        #print("  #Bug parameters: n=",n,"w=",w,"m=",m,"rs=",rs)
+                        #break
+                        continue
                     spread=abs(round(train_score-test_score,3))
                     
                     row=pd.Series({'spread':spread,'train_score':train_score, \
                                    'test_score':test_score,'neighbours':n, \
                                    'weight':w,'metric':m,'random':rs,'pred':prediction})
                     results=results.append(row,ignore_index=True)
-        print(int(n/n_num*100),'\b%, ',end='')
-    print('done.') 
+        print(int(n/n_num*100),'\b% ',end='')
+    print('.') 
+    
+    # 过滤训练/测试分数差的结果
+    """
+    r0=results[(results['train_score']>=min_score) & (results['test_score']>=min_score)]
+    
+    # 如果最低分数设置太高
+    r0_len=len(r0)
+    if r0_len==0:
+        train_score_max=results['train_score'].max()
+        test_score_max=results['test_score'].max()
+        min_score_new=min(train_score_max,test_score_max)
+        r0=results[(results['train_score']>=min_score_new) & (results['test_score']>=min_score_new)]
+        
+        if len(r0)==0:
+            spread_quantile=results['spread'].quantile(q=0.01)
+            r0_spread=results[(results['spread']<spread_quantile)]
+            if len(r0_spread)==0:
+                r0_spread=results[(results['spread']<=spread_quantile)]
+
+            test_score_quantile=r0_spread['test_score'].quantile(q=0.99)
+            r0=r0_spread[(r0_spread['test_score']>test_score_quantile)]
+            if len(r0)==0:
+                r0=r0_spread[(r0_spread['test_score']>=test_score_quantile)]
+                
+            train_score_max=r0['train_score'].max()
+            test_score_max=r0['test_score'].max()
+            min_score_new=min(train_score_max,test_score_max)
+            
+        print("  #Warning: filtering parameter min_score has been adjusted to",min_score_new)        
+    """
+    
+    train_score_max=results['train_score'].max()
+    test_score_max=results['test_score'].max()
+    min_score_new=min(train_score_max,test_score_max)
+    r0=results[(results['train_score']>=min_score_new) & (results['test_score']>=min_score_new)]
+    
+    if len(r0)==0:
+        spread_quantile=results['spread'].quantile(q=0.01)
+        r0_spread=results[(results['spread']<spread_quantile)]
+        if len(r0_spread)==0:
+            r0_spread=results[(results['spread']<=spread_quantile)]
+
+        test_score_quantile=r0_spread['test_score'].quantile(q=0.99)
+        r0=r0_spread[(r0_spread['test_score']>test_score_quantile)]
+        if len(r0)==0:
+            r0=r0_spread[(r0_spread['test_score']>=test_score_quantile)]
+            
+        train_score_max=r0['train_score'].max()
+        test_score_max=r0['test_score'].max()
+        min_score_new=min(train_score_max,test_score_max)
     
-    #去掉严重过拟合的结果           
-    r0=results[results['train_score'] < 1]
-    #去掉训练集、测试集分数不过半的模型    
-    r0=r0[r0['train_score'] > min_score]
-    r0=r0[r0['test_score'] > min_score]
     #去掉泛化效果差的结果
-    r0=r0[r0['spread'] < diff]  #限定泛化差距
-    #优先查看泛化效果最优的结果
-    r1=r0.sort_values(by=['spread','test_score'],ascending=[True,False])        
-    #优先查看测试分数最高的结果
-    r2=r0.sort_values(by=['test_score','spread'],ascending=[False,True])
-
-    if votes > len(r2): votes=len(r2)
-    r2head=r2.head(votes)
+    """
+    r1=r0[r0['spread'] <= diff]  #限定泛化差距
+    r1_len=len(r1)
+    
+    if r1_len==0:
+        diff_new=r0['spread'].min()
+        r1=r0[r0['spread'] <= diff_new]
+        print("  #Warning: filtering parameter diff has been adjusted to",diff_new)
+    """
     
+    diff_new=r0['spread'].min()
+    r1=r0[r0['spread'] == diff_new]
     
-    #加权平均股价
-    r2head['w_pred']=r2head['pred'] * r2head['test_score']
-    w_pred_sum=r2head['w_pred'].sum()
-    test_score_sum=r2head['test_score'].sum()
-    decision=round(w_pred_sum / test_score_sum,2)
-    decision_score=round(r2head['test_score'].mean(),2)
+    #优先查看泛化效果最优的结果：spread最小
+    """
+    votes=min(votes,len(r1))
+    r2=r1.sort_values(by=['spread','test_score'],ascending=[True,False]).head(votes)        
+    #优先查看测试分数最高的结果：test_score最大
+    r3=r2.sort_values(by=['test_score','spread'],ascending=[False,True])
+    """
+    
+    r3head=r1
+    #平均股价
+    decision=round(r3head['pred'].mean(),2)
+    decision_score=round(r3head['test_score'].mean(),3)
     
+    """
+    r3head['w_pred']=r3head['pred'] * r3head['test_score']
+    w_pred_sum=r3head['w_pred'].sum()
+    test_score_sum=r3head['test_score'].sum()
+    decision=round(w_pred_sum / test_score_sum,2)
+    decision_score=round(r3head['test_score'].mean(),2)
+    """
     """
     #股价中位数：偶尔出现奇怪的错误，未找到原因
-    decision0=r2head['pred'].median()
-    pos=list(r2head['pred']).index(decision0)
-    decision_score0=list(r2head['test_score'])[pos]
+    decision0=r3head['pred'].median()
+    pos=list(r3head['pred']).index(decision0)
+    decision_score0=list(r3head['test_score'])[pos]
     decision=round(decision0,2)
     decision_score=round(decision_score0,2)
     """
     import numpy as np
-    if decision == np.nan: decision='?'
+    if np.isnan(decision): decision='?'
     
     if not printout: return decision,decision_score,today_close,today
 
     print("  Model poll for stock price after "+str(ndays)+" trading days:",decision)
-    print("Last close price: "+ticker+', '+str(today_close)+', '+str(today))
-    print("Prediction for stock price after "+str(ndays)+" trading day:",decision)
-    return decision,decision_score,today_close,today
+    print("  Last close price: "+codetranslate(ticker)+', closed '+str(known_close)+', '+str(known_day))
+    
+    ndate=date_adjust(known_day,adjust=ndays)
+        
+    print("  Prediction for stock close price on",ndate,"\b:",decision)
+    
+    return decision,decision_score,known_close,known_day
 
-if __name__=='__main__':
-    df=get_money_flowin(ticker)
-    df=price_price_knn('600519',df,ndays=1,max_neighbours=3,max_RS=2)
     
 #==============================================================================
 if __name__=='__main__':
-    ticker='600519'
+    ticker='600519.SS'
     ndays=1
-    market='sh'
-    diff=0.03
-    votes=100
     max_neighbours=3
     max_RS=2
+    
+    forecast=forecast_price_knn(ticker,ndays=1,end='2023-6-15')
+    forecast=forecast_price_knn(ticker,ndays=3,end='2023-6-15')
 
-def forecast_price_knn(ticker,ndays=1,diff=0.03,min_score=0.6,votes=100,max_neighbours=10,max_RS=10):
-
+#def forecast_price_knn(ticker,ndays=1,diff=0.03,min_score=0.7,votes=100,max_neighbours=10,max_RS=10,end='latest'):
+def forecast_price_knn(ticker,ndays=1,max_neighbours=10,max_RS=20,end='latest'):
     """
     功能：基于个股资金流动预测未来股票价格
     ticker：股票代码，无后缀
     ndays：预测几天后的股价，默认1天
-    market：sh-沪市，sz-深市
-    diff：泛化精度，越小越好，默认0.03
-    votes：软表决均值，默认最大100
+    diff：弃用。泛化精度，越小越好
+    min_score：弃用。最小训练/测试分数，越大越好
+    votes：弃用。软表决均值，默认最大100
     max_neighbours：最大邻居个数，默认10个
-    max_RS：最大随机数种子，默认最大为10
+    max_RS：最大随机数种子，越大越好
+    
+    注意：结果经常相当不靠谱！
     """
     print("\nStart forecasting, it may take great time, please wait ...")
     
     #抓取个股资金净流入情况df和大盘指数情况dp
-    df0=get_money_flowin(ticker)
-    
-    #测试用
-    df=df0.copy()
+    df=get_money_flowin(ticker,end=end)
     
     #预测未来股价涨跌
     decisionlist=[]
     confidencelist=[]
     for nd in list(range(1,ndays+1)):
-        decision,confidence,today_close,today=price_price_knn(ticker,df,ndays=nd, \
-            diff=diff,min_score=min_score,votes=votes,max_neighbours=max_neighbours,max_RS=max_RS)
+        """
+        decision,confidence,known_close,known_day=price_price_knn(ticker,df,ndays=nd, \
+                                                              diff=diff, \
+                                                              min_score=min_score, \
+                                                              votes=votes, \
+                                                              max_neighbours=max_neighbours, \
+                                                              max_RS=max_RS)
+        """
+        decision,confidence,known_close,known_day=price_price_knn(ticker,df,ndays=nd, \
+                                                              max_neighbours=max_neighbours, \
+                                                              max_RS=max_RS)
+        
         decisionlist=decisionlist+[decision]
         confidencelist=confidencelist+[confidence]
 
-    print("\nStock information:",ticker,today_close,today)
-    print("Forecasting stock prices in next",ndays,"trading days: ",end='')
-    for i in decisionlist:
-        pos=decisionlist.index(i)
-        conf=confidencelist[pos]
-        if i == '?':
-            print('?',end='')
+    print("\nStock information:",codetranslate(ticker),'\b, closed',known_close,'@',known_day)
+
+    for nd in list(range(1,ndays+1)):
+        ndate=date_adjust(known_day, adjust=nd)
+        pred=decisionlist[nd-1]  
+        conf=confidencelist[nd-1]
+        
+        if (pred != 0) & (conf != 0):
+            if pred != '?':
+                diff=decision - known_close
+                if abs(diff) < 0.05:
+                    comment="MINOR difference with previous one"
+                elif diff > 0:
+                    comment="HIGHER than previous one"
+                else:
+                    comment="LOWER than previous one"
+                
+                print("Forecasting stock prices on",ndate,'\b:',pred,'('+str(round(conf*100,1))+'% confident)')
+                print("Forecasting stock prices trend on",ndate,'\b:',comment)
+            else:
+                print("Forecasting stock prices on",ndate,'\b: uncertain')
         else:
-            print(str(i)+'('+str(conf*100)+'%) ',end='')
-    print('\b.')
+            print("Forecasting stock prices on",ndate,'\b: market closed')
     
-    return
+    return decisionlist,confidencelist
 
-if __name__=='__main__':
-    df=forecast_price_knn('600519',ndays=1,max_neighbours=5,max_RS=2)
 
 #==============================================================================
 #==============================================================================