在统计分析中，相关性系数 ( r ) 和 p 值都提供了关于变量之间关系的重要信息。以下是如何评价和解释你的结果，并考虑该因子对因变量的影响。1. 相关性系数 ( r )**相关性系数 ( r = 0.29 )**：相关系数 ( r ) 的取值范围在 -1 到 1 之间。具体解释如下：0.00–0.10：几乎无相关性0.10–0.30：弱相关性0.30–0.50：中等相关性0.50：强相关性因此，( r = 0.29 ) 表示变量之间存在弱相关性。2. p 值p < 0.05：表示相关性在统计学上显著。这意味着在 95% 的置信水平下，我们可以拒绝无关的原假设，即变量之间确实存在一定程度的相关性。3. 综合评价虽然 p 值表明相关性在统计学上显著，但相关性系数 ( r ) 很低，只说明变量间存在弱相关性。在撰写文章时，你可以根据分析的上下文来决定如何总结这些结果。通常会考虑以下几点：4. 解读和结论在文章中，可以这样总结：明确您的发现：“我们的分析显示，这两个变量之间存在统计显著的相关性（p < 0.05），但相关性系数 ( r = 0.29 ) 表示这种相关性很弱。”讨论相关性的实际意义：“尽管相关性在统计学上显著，但由于相关性系数较低，表明这两个变量之间的关系在实际中可能并不强。”是否忽略该变量：在解释是否忽略该变量时，可以结合领域知识和研究背景。如果仅凭 ( r ) 值判断，弱相关性一般建议谨慎处理，而非完全忽视。你可以进一步探讨变量的实际影响或在多元回归模型中验证其贡献。5. 多元回归分析为了更好地理解该变量对因变量的影响，可以进行多元线性回归分析，在控制其他变量的情况下评估该变量的独立贡献。Python 实现 import pandas as pdimport statsmodels.api as sm# 假设df是你的数据框，X是自变量，y是因变量X = df[['your_variable', 'other_variables']] # 添加其他控制变量y = df['dependent_variable']# 添加常数项（截距）X = sm.add_constant(X)# 拟合回归模型model = sm.OLS(y, X).fit()# 输出模型摘要print(model.summary())R 实现 # 假设df是你的数据框，X是自变量，y是因变量model <- lm(dependent_variable ~ your_variable + other_variables, data=df)# 输出模型摘要summary(model)通过上述多元回归分析，可以评估该变量的系数及其显著性。如果该变量在多元回归中仍然不显著，则可以更合理地考虑忽略它。6. 总结根据 p 值和相关性系数 ( r )，可以得出以下结论：虽然统计上显著（p < 0.05），但相关性较弱（( r = 0.29 )）。在总结中，应强调这种弱相关性，并结合领域知识决定是否忽略该变量。通过多元回归分析进一步验证该变量的独立贡献，有助于做出更全面的判断。

1.机器学习的主要任务：一是将实例数据划分到合适的分类中，即分类问题。 而是是回归， 它主要用于预测数值型数据，典型的回归例子：数据拟合曲线。2.监督学习和无监督学习：分类和回归属于监督学习，之所以称之为监督学习，是因为这类算法必须直到预测什么，即目标变量的分类信息。对于无监督学习，此时数据没有类别信息，也不会给定目标值。在无监督学习中，将数据集合分成由类似的对象组成的多个类的过程被成为聚类；将寻找描述数据统计值的过程称之为密度估计。此外，无监督学习还可以减少数据特征的维度，以便我们可以使用二维或者三维图形更加直观地展示数据信息。3.线性回归和非线性回归　　线性回归需要一个线性模型。一个线性的模型意味着模型的每一项要么是一个常数，要么是一个常数和一个预测变量的乘积。一个线性等式等于每一项相加的和。等式：Response = constant + parameter * predictor + ... + parameter * predictor　　<=>　　Y = b o + b1X1 + b2X2 + ... + bkXk在统计学中，如果一个回归方程是线性的，那么它的参数必须是线性的。但是可以转换预测变量加上平方，来使得模型产生曲线，比如 Y = b o + b1X1 + b2X12这时模型仍然是线性的，虽然预测变量带有平方。当然加上log或者反函数也可以。

内容介绍本文重点在于如何利用python收集各类型因子并进行预处理最终用于构建量化选股模型。工具介绍本代码所需要调用的包如下图所示：import pandas as pdimport tushare as tspro = ts.pro_api()import numpy as npimport timeimport mathimport statsmodels.api as smfrom sklearn import preprocessingfrom sklearn.decomposition import PCAimport os这里需要用到的是python中的pandas和statsmodels模块，分别用于数据处理和做多元回归。另外，还需要获取股票和指数的各项数据，这里所用到的是tushare，tushare拥有丰富的数据内容，如股票、基金等行情数据，公司财务理等基本面数据。通过tushare平台赚取一定的积分可以免费获取平台提供的数据。(个人ID：419382）数据获取本段代码展示了如何通过tushare获取相关数据并清洗成为所需因子，共展示了估值因子，成长因子，财务质量因子，杠杆因子，动量反转因子，波动率因子以及beta的构建。其中beta因子是取个股与指数收益率线性回归的回归系数。def get_all_factors(codes_list,date,start,end,one_m_start,beta_start,beta_end):    #获取估值因子    evaluate_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定交易日的指标        df1 = pro.daily_basic(ts_code=codes_list[i],trade_date=date,fields="ts_code,trade_date,pe_ttm,pb,ps_ttm,dv_ttm")        evaluate_factors = evaluate_factors.append(df1)        time.sleep(0.4)        print("第%d支股票估值因子获取成功"%i)    #根据指标计算因子    evaluate_factors["EP"] = 1/evaluate_factors["pe_ttm"]     evaluate_factors["BP"] = 1/evaluate_factors["pb"]    evaluate_factors["SP"] = 1/evaluate_factors["ps_ttm"]    evaluate_factors["DP"] = evaluate_factors["dv_ttm"]    evaluate_factors = evaluate_factors[["ts_code","trade_date","EP","BP","SP","DP"]]        #获取成长因子    growth_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定日期最近的财报        df1 = pro.income(ts_code=codes_list[i],end_date=date,                          fields="ts_code,end_date,revenue,n_income")        df1 = df1.drop_duplicates(subset=["end_date"])    #根据财报计算因子        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[[0,4],:]        revenue = df1["revenue"].tolist()        n_income = df1["n_income"].tolist()        sales_G = revenue[0]/revenue[1] - 1        profit_G = n_income[0]/n_income[1] - 1        df2 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df2 = df2.drop_duplicates(subset=["end_date"])        df2["end_date"] = df2["end_date"].astype("int64")        df2 = df2.iloc[[0,4],:]        roe = df2["roe"].tolist()        ROE_G = roe[0]/roe[1] - 1        df3 = pd.DataFrame({"ts_code":codes_list[i],"sales_G":sales_G,"profit_G":profit_G,"ROE_G":ROE_G},index=[20201231])        growth_factors = growth_factors.append(df3)        time.sleep(1.2)        print("第%d支股票成长因子获取成功"%i)    all_factors = evaluate_factors.merge(growth_factors)        #获取财务质量因子    quality_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定日期最近的财报        df1 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[0,:]        df1 = df1[["ts_code","roe","assets_turn"]]        quality_factors = quality_factors.append(df1)        time.sleep(1)        print("第%d支股票财务质量获取成功"%i)    all_factors = all_factors.merge(quality_factors)    #获取杠杆因子    leverage_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[0,:]        df1 = df1[["ts_code","debt_to_assets"]]        leverage_factors = leverage_factors.append(df1)        time.sleep(0.8)        print("第%d支股票杠杆因子获取成功"%i)    all_facotrs = all_factors.merge(leverage_factors)            #获取市值因子    capital_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.daily_basic(ts_code=codes_list[i],trade_date=date,fields="ts_code,total_mv")        df1["total_mv"] = df1["total_mv"].apply(lambda x:math.log(x))        capital_factors = capital_factors.append(df1)        time.sleep(0.5)        print("第%d支股票市值因子获取成功"%i)    all_factors = all_facotrs.merge(capital_factors)            #获取动量反转因子    return_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = ts.pro_bar(ts_code=codes_list[i], freq='M', adj='hfq')        df1["trade_date"] = df1["trade_date"].astype("int64")        close = df1["close"].tolist()        return_1m = df1["pct_chg"].tolist()[0]        return_3m = close[0]/close[3] - 1        df2 = ts.pro_bar(ts_code=codes_list[i], adj='hfq')        df2["trade_date"] = df2["trade_date"].astype("int64")        df3 = pro.daily_basic(ts_code=codes_list[i],start_date=start,end_date=end,fields="ts_code,trade_date,turnover_rate")        df3["trade_date"] = df3["trade_date"].astype("int64")        df2 = df2[df2["trade_date"]>=start]        w_return_3m = (df2["pct_chg"]*df3["turnover_rate"]).sum()/len(df2)        df_1m_return = df2[df2["trade_date"]>=one_m_start]        df_1m_turnover = df3[df3["trade_date"]>=one_m_start]        w_return_1m = (df_1m_return["pct_chg"]*df_1m_turnover["turnover_rate"]).sum()/len(df_1m_return)                df4 = pd.DataFrame({"ts_code":codes_list[i],                            "return_1m":return_1m,"return_3m":return_3m,"w_return_1m":w_return_1m,"w_return_3m":w_return_3m},index=[0])        return_factors = return_factors.append(df4)        print("第%d支股票动量反转因子获取成功"%i)    all_factors = all_factors.merge(return_factors)                    #获取波动率因子    vol_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = ts.pro_bar(ts_code=codes_list[i], adj='hfq')        df1["trade_date"] = df1["trade_date"].astype("int64")        df2 = df1[df1["trade_date"]>=start]        std_1m = df2["pct_chg"].std()        df3 = df1[df1["trade_date"]>=one_m_start]        std_3m = df3["pct_chg"].std()        df4 = pd.DataFrame({"ts_code":codes_list[i],"std_1m":std_1m,"std_3m":std_3m},index=[0])        vol_factors = vol_factors.append(df4)        print("第%d支股票波动率因子获取成功"%i)    all_factors = all_factors.merge(vol_factors)    #获取beta    beta_factors = pd.DataFrame()    rf = 1.03**(1/360) - 1    hs300 = pro.index_daily(ts_code="399300.SZ",start_date=beta_start,end_date=beta_end)    hs300["rm"] = hs300["pct_chg"]/100 - rf    for i in range(len(codes_list)):        df1 = pro.daily(ts_code=codes_list[i],start_date=beta_start,end_date=beta_end)        df1["rp"] = df1["pct_chg"]/100 - rf        df_model = pd.merge(hs300[["trade_date","rm"]],df1[["trade_date","rp"]],on="trade_date")        df_model.index = pd.to_datetime(df1.trade_date)        df_model.sort_index(inplace=True)        model = sm.OLS(df_model["rp"],sm.add_constant(df_model["rm"]))        result = model.fit()        beta = result.params["rm"]        df2 = pd.DataFrame({"ts_code":codes_list[i],"beta":beta},index=[0])        beta_factors = beta_factors.append(df2)        print("第%d支股票beta因子获取成功"%i)    all_factors = all_factors.merge(beta_factors)    #获取换手率因子    turn_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.daily_basic(ts_code=codes_list[i],start_date=start,end_date=end,fields="ts_code,trade_date,turnover_rate")        df1["trade_date"] = df1["trade_date"].astype("int64")        turn_3m = df1["turnover_rate"].sum().mean()        df2 = df1[df1["trade_date"]>=one_m_start]        turn_1m = df2["turnover_rate"].sum().mean()        df3 = pd.DataFrame({"ts_code":codes_list[i],"turn_1m":turn_1m,"turn_3m":turn_3m},index=[0])        turn_factors = turn_factors.append(df3)        print("第%d支股票换手率因子获取成功"%i)        time.sleep(0.3)    all_factors = all_factors.merge(turn_factors)        return all_factors    数据预处理本段的数据预处理显示获取个股所属行业，这一部分需要先在网上下载一份上司公司所属中信一级行业的表格（即代码中的“ industry.xlsx ”）。之后再用merge函数合并进数据表中。之后可以利用所属行业进行行业市值中性化处理，其他预处理步骤包括中位数去极值，缺失值处理，标准化和PCA。这里的PCA主要是为了去除多重共线性的影响，不在于筛选因子。#获取标签def get_tag(data,date):    stocks = data["ts_code"].tolist()    rm = pro.index_monthly(ts_code="399300.SZ",trade_date=date).pct_chg.tolist()    return_list=[]    for i in range(len(stocks)):        r = pro.monthly(ts_code=stocks[i], trade_date=date).pct_chg.tolist()        return_list.append(r[0]-rm[0])        print("第%d支股票超额收益计算完成"%i)        time.sleep(0.5)    data["ex_return"] = return_list    return data#获取行业def get_industry(data):    df1 = pd.read_excel(r"industry.xlsx",dtype="object")    df1 = df1.rename(columns={"code":"ts_code"})    ts_codes = data["ts_code"].tolist()    data["ts_code"] = data["ts_code"].apply(lambda x:x[0:6])    data = data.merge(df1,on="ts_code")    data["ts_code"] = ts_codes    return data#数据预处理#中位数去极值def MAD(data,n):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        Dm = data[indexes[i]].quantile(0.5)        Dm1 = ((data[indexes[i]] - Dm).abs()).quantile(0.5)        max_range = Dm + n*Dm1        min_range = Dm - n*Dm1        data[indexes[i]] = np.clip(data[indexes[i]],min_range,max_range)    return data#缺失值处理def Miss_data(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        data[indexes[i]] = data.groupby("industry")[indexes[i]].transform(lambda x:x.fillna(x.mean()))    return data#市值行业中性化def Indifference(data):    data2 = data.drop_duplicates(subset=["industry"])    list1 = data2["industry"].tolist()    list2 = data["industry"].tolist()    industry_matrix = pd.DataFrame(columns=list1)    industry_names = industry_matrix.columns.values.tolist()    for each in range(len(industry_names)):        for i in range(len(list2)):            if list2[i] == list1[each]:                list2[i] = 1            else:                list2[i] = 0        industry_matrix[list1[each]] = list2        list2 = data["industry"].tolist()    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        model = sm.OLS(data[indexes[i]],sm.add_constant(industry_matrix))        result = model.fit()        data[indexes[i]] = result.resid    return data#标准化def Standardize(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    data[indexes] = preprocessing.scale(data[indexes])    return data        #主成分分析def PCA_data(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    pca = PCA(n_components=20)    new_data = pca.fit_transform(data[indexes])    new_data = pd.DataFrame(new_data)    data[indexes] = new_data    return data模型构建到这里之后用于回归模型的数据集就已经构建完成了，利用传统机器学习的步骤，将数据集分为训练集和测试集，训练集为T-2期至T-12期的数据，测试集为T-1期的数据，本模型最终目的是利用T-1期的数据预测T期个股的超额收益率。

内容介绍本文重点在于如何利用python收集各类型因子并进行预处理最终用于构建量化选股模型。工具介绍本代码所需要调用的包如下图所示：import pandas as pdimport tushare as tspro = ts.pro_api()import numpy as npimport timeimport mathimport statsmodels.api as smfrom sklearn import preprocessingfrom sklearn.decomposition import PCAimport os这里需要用到的是python中的pandas和statsmodels模块，分别用于数据处理和做多元回归。另外，还需要获取股票和指数的各项数据，这里所用到的是tushare，tushare拥有丰富的数据内容，如股票、基金等行情数据，公司财务理等基本面数据。通过tushare平台赚取一定的积分可以免费获取平台提供的数据。(个人ID：419382）数据获取本段代码展示了如何通过tushare获取相关数据并清洗成为所需因子，共展示了估值因子，成长因子，财务质量因子，杠杆因子，动量反转因子，波动率因子以及beta的构建。其中beta因子是取个股与指数收益率线性回归的回归系数。def get_all_factors(codes_list,date,start,end,one_m_start,beta_start,beta_end):    #获取估值因子    evaluate_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定交易日的指标        df1 = pro.daily_basic(ts_code=codes_list[i],trade_date=date,fields="ts_code,trade_date,pe_ttm,pb,ps_ttm,dv_ttm")        evaluate_factors = evaluate_factors.append(df1)        time.sleep(0.4)        print("第%d支股票估值因子获取成功"%i)    #根据指标计算因子    evaluate_factors["EP"] = 1/evaluate_factors["pe_ttm"]     evaluate_factors["BP"] = 1/evaluate_factors["pb"]    evaluate_factors["SP"] = 1/evaluate_factors["ps_ttm"]    evaluate_factors["DP"] = evaluate_factors["dv_ttm"]    evaluate_factors = evaluate_factors[["ts_code","trade_date","EP","BP","SP","DP"]]        #获取成长因子    growth_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定日期最近的财报        df1 = pro.income(ts_code=codes_list[i],end_date=date,                          fields="ts_code,end_date,revenue,n_income")        df1 = df1.drop_duplicates(subset=["end_date"])    #根据财报计算因子        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[[0,4],:]        revenue = df1["revenue"].tolist()        n_income = df1["n_income"].tolist()        sales_G = revenue[0]/revenue[1] - 1        profit_G = n_income[0]/n_income[1] - 1        df2 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df2 = df2.drop_duplicates(subset=["end_date"])        df2["end_date"] = df2["end_date"].astype("int64")        df2 = df2.iloc[[0,4],:]        roe = df2["roe"].tolist()        ROE_G = roe[0]/roe[1] - 1        df3 = pd.DataFrame({"ts_code":codes_list[i],"sales_G":sales_G,"profit_G":profit_G,"ROE_G":ROE_G},index=[20201231])        growth_factors = growth_factors.append(df3)        time.sleep(1.2)        print("第%d支股票成长因子获取成功"%i)    all_factors = evaluate_factors.merge(growth_factors)        #获取财务质量因子    quality_factors = pd.DataFrame()    for i in range(len(codes_list)):    #获取给定日期最近的财报        df1 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[0,:]        df1 = df1[["ts_code","roe","assets_turn"]]        quality_factors = quality_factors.append(df1)        time.sleep(1)        print("第%d支股票财务质量获取成功"%i)    all_factors = all_factors.merge(quality_factors)    #获取杠杆因子    leverage_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.fina_indicator(ts_code=codes_list[i],end_date=date)        df1["end_date"] = df1["end_date"].astype("int64")        df1 = df1.iloc[0,:]        df1 = df1[["ts_code","debt_to_assets"]]        leverage_factors = leverage_factors.append(df1)        time.sleep(0.8)        print("第%d支股票杠杆因子获取成功"%i)    all_facotrs = all_factors.merge(leverage_factors)            #获取市值因子    capital_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.daily_basic(ts_code=codes_list[i],trade_date=date,fields="ts_code,total_mv")        df1["total_mv"] = df1["total_mv"].apply(lambda x:math.log(x))        capital_factors = capital_factors.append(df1)        time.sleep(0.5)        print("第%d支股票市值因子获取成功"%i)    all_factors = all_facotrs.merge(capital_factors)            #获取动量反转因子    return_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = ts.pro_bar(ts_code=codes_list[i], freq='M', adj='hfq')        df1["trade_date"] = df1["trade_date"].astype("int64")        close = df1["close"].tolist()        return_1m = df1["pct_chg"].tolist()[0]        return_3m = close[0]/close[3] - 1        df2 = ts.pro_bar(ts_code=codes_list[i], adj='hfq')        df2["trade_date"] = df2["trade_date"].astype("int64")        df3 = pro.daily_basic(ts_code=codes_list[i],start_date=start,end_date=end,fields="ts_code,trade_date,turnover_rate")        df3["trade_date"] = df3["trade_date"].astype("int64")        df2 = df2[df2["trade_date"]>=start]        w_return_3m = (df2["pct_chg"]*df3["turnover_rate"]).sum()/len(df2)        df_1m_return = df2[df2["trade_date"]>=one_m_start]        df_1m_turnover = df3[df3["trade_date"]>=one_m_start]        w_return_1m = (df_1m_return["pct_chg"]*df_1m_turnover["turnover_rate"]).sum()/len(df_1m_return)                df4 = pd.DataFrame({"ts_code":codes_list[i],                            "return_1m":return_1m,"return_3m":return_3m,"w_return_1m":w_return_1m,"w_return_3m":w_return_3m},index=[0])        return_factors = return_factors.append(df4)        print("第%d支股票动量反转因子获取成功"%i)    all_factors = all_factors.merge(return_factors)                    #获取波动率因子    vol_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = ts.pro_bar(ts_code=codes_list[i], adj='hfq')        df1["trade_date"] = df1["trade_date"].astype("int64")        df2 = df1[df1["trade_date"]>=start]        std_1m = df2["pct_chg"].std()        df3 = df1[df1["trade_date"]>=one_m_start]        std_3m = df3["pct_chg"].std()        df4 = pd.DataFrame({"ts_code":codes_list[i],"std_1m":std_1m,"std_3m":std_3m},index=[0])        vol_factors = vol_factors.append(df4)        print("第%d支股票波动率因子获取成功"%i)    all_factors = all_factors.merge(vol_factors)    #获取beta    beta_factors = pd.DataFrame()    rf = 1.03**(1/360) - 1    hs300 = pro.index_daily(ts_code="399300.SZ",start_date=beta_start,end_date=beta_end)    hs300["rm"] = hs300["pct_chg"]/100 - rf    for i in range(len(codes_list)):        df1 = pro.daily(ts_code=codes_list[i],start_date=beta_start,end_date=beta_end)        df1["rp"] = df1["pct_chg"]/100 - rf        df_model = pd.merge(hs300[["trade_date","rm"]],df1[["trade_date","rp"]],on="trade_date")        df_model.index = pd.to_datetime(df1.trade_date)        df_model.sort_index(inplace=True)        model = sm.OLS(df_model["rp"],sm.add_constant(df_model["rm"]))        result = model.fit()        beta = result.params["rm"]        df2 = pd.DataFrame({"ts_code":codes_list[i],"beta":beta},index=[0])        beta_factors = beta_factors.append(df2)        print("第%d支股票beta因子获取成功"%i)    all_factors = all_factors.merge(beta_factors)    #获取换手率因子    turn_factors = pd.DataFrame()    for i in range(len(codes_list)):        df1 = pro.daily_basic(ts_code=codes_list[i],start_date=start,end_date=end,fields="ts_code,trade_date,turnover_rate")        df1["trade_date"] = df1["trade_date"].astype("int64")        turn_3m = df1["turnover_rate"].sum().mean()        df2 = df1[df1["trade_date"]>=one_m_start]        turn_1m = df2["turnover_rate"].sum().mean()        df3 = pd.DataFrame({"ts_code":codes_list[i],"turn_1m":turn_1m,"turn_3m":turn_3m},index=[0])        turn_factors = turn_factors.append(df3)        print("第%d支股票换手率因子获取成功"%i)        time.sleep(0.3)    all_factors = all_factors.merge(turn_factors)        return all_factors    数据预处理本段的数据预处理显示获取个股所属行业，这一部分需要先在网上下载一份上司公司所属中信一级行业的表格（即代码中的“ industry.xlsx ”）。之后再用merge函数合并进数据表中。之后可以利用所属行业进行行业市值中性化处理，其他预处理步骤包括中位数去极值，缺失值处理，标准化和PCA。这里的PCA主要是为了去除多重共线性的影响，不在于筛选因子。#获取标签def get_tag(data,date):    stocks = data["ts_code"].tolist()    rm = pro.index_monthly(ts_code="399300.SZ",trade_date=date).pct_chg.tolist()    return_list=[]    for i in range(len(stocks)):        r = pro.monthly(ts_code=stocks[i], trade_date=date).pct_chg.tolist()        return_list.append(r[0]-rm[0])        print("第%d支股票超额收益计算完成"%i)        time.sleep(0.5)    data["ex_return"] = return_list    return data#获取行业def get_industry(data):    df1 = pd.read_excel(r"industry.xlsx",dtype="object")    df1 = df1.rename(columns={"code":"ts_code"})    ts_codes = data["ts_code"].tolist()    data["ts_code"] = data["ts_code"].apply(lambda x:x[0:6])    data = data.merge(df1,on="ts_code")    data["ts_code"] = ts_codes    return data#数据预处理#中位数去极值def MAD(data,n):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        Dm = data[indexes[i]].quantile(0.5)        Dm1 = ((data[indexes[i]] - Dm).abs()).quantile(0.5)        max_range = Dm + n*Dm1        min_range = Dm - n*Dm1        data[indexes[i]] = np.clip(data[indexes[i]],min_range,max_range)    return data#缺失值处理def Miss_data(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        data[indexes[i]] = data.groupby("industry")[indexes[i]].transform(lambda x:x.fillna(x.mean()))    return data#市值行业中性化def Indifference(data):    data2 = data.drop_duplicates(subset=["industry"])    list1 = data2["industry"].tolist()    list2 = data["industry"].tolist()    industry_matrix = pd.DataFrame(columns=list1)    industry_names = industry_matrix.columns.values.tolist()    for each in range(len(industry_names)):        for i in range(len(list2)):            if list2[i] == list1[each]:                list2[i] = 1            else:                list2[i] = 0        industry_matrix[list1[each]] = list2        list2 = data["industry"].tolist()    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    for i in range(len(indexes)):        model = sm.OLS(data[indexes[i]],sm.add_constant(industry_matrix))        result = model.fit()        data[indexes[i]] = result.resid    return data#标准化def Standardize(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    data[indexes] = preprocessing.scale(data[indexes])    return data        #主成分分析def PCA_data(data):    indexes = data.columns.values.tolist()    indexes = indexes[2:len(indexes)-1]    pca = PCA(n_components=20)    new_data = pca.fit_transform(data[indexes])    new_data = pd.DataFrame(new_data)    data[indexes] = new_data    return data模型构建到这里之后用于回归模型的数据集就已经构建完成了，利用传统机器学习的步骤，将数据集分为训练集和测试集，训练集为T-2期至T-12期的数据，测试集为T-1期的数据，本模型最终目的是利用T-1期的数据预测T期个股的超额收益率。

原文链接：https://blog.csdn.net/weixin_43212535/article/details/122393250线性回归模型属于经典的统计学模型，该模型的应用场景是根据已知的变量（自变量）来预测某个连续的数值变量（因变量），线性回归通常可以应用在股价预测、营收预测、广告效果预测、销售业绩预测当中。一元线性回归：基本概念：一元线性回归是分析只有一个自变量（自变量x和因变量y）线性相关关系的方法。一个经济指标的数值往往受许多因素影响，若其中只有一个因素是主要的，起决定性作用，则可用一元线性回归进行预测分析。数据集可以表示成{(x1,y1),(x2,y2),…,(xn,yn)}。其中，xi表示自变量x的第i个值，yi表示因变量y的第i个值，n表示数据集的样本量。当模型构建好之后，就可以根据其他自变量x的值，预测因变量y的值，该模型的数学公式可以表示成： python中展示：导入我们需要的包和相关库#引入sklearn库，使用其中的线性回归模块from sklearn import  datasets,linear_model#引入train_test_split来把我们的数据集分为训练集和测试集from sklearn.model_selection import train_test_splitimport numpy as npimport pandas as pdimport matplotlib.pyplot as plt# 创建数据集  比如我们现在有10行2列数据，第一列是身高，第二列是体重，通常做法：将原始数据切分时，将原始数据的80%作为训练数据来训练模型，另外20%作为测试数据，通过测试数据直接判断模型的效果，在模型进入真实环境前不断改进模型；data = np.array([[152,51],[156,53],[160,54],[164,55],                 [168,57],[172,60],[176,62],[180,65],                 [184,69],[188,72]]) # X,y分别存放特征向量和标签，这里边使用reshape的目的是data[:,0]是一个一维的数组，但后边模型调用的时候要求是矩阵的形式X,y = data[:,0].reshape(-1,1),data[:,1]# 训练集和测试集区分开# train_size=0.8的意思就是随机提取80%的数据作为训练数据X_train,X_test,y_train,y_test = train_test_split(X,y,train_size=0.8) # 实现线性回归算法模型regr = linear_model.LinearRegression()# 拟合数据,训练模型regr.fit(X_train,y_train)# score得到的返回结果是决定系数R平方值regr.score(X_train,y_train)决定系数R的平方值 = 1-u/vu = (y的实际值-y的预期值)的平方的求和v = (y的实际值-y的实际值的平均值)的平方的求和--输出结果R的平方值=0.963944147932503font = {'family':"SimHei",'size':20}plt.rc('font',**font)##训练数据plt.scatter(X_train,y_train,color='r')##画拟合线plt.plot(X_train,regr.predict(X_train),color='b')plt.scatter(X_test,y_test,color='black')# 测试数据plt.xlabel('身高')plt.ylabel('体重')plt.show() 下面让我们简单的做一个预测，加入身高是170的人，他的体重是多少那？np.round(regr.predict([[170]]),1)array([59.8]),可以看到170的人，经过我们的预测他的体重是59.8公斤。

多层感知器 现在我们来介绍多层感知器（MLP）。通过添加非线性的激活函数以及使用多层网络的结构，多层感知器延展了单层感知器的功能。在训练中，我们需要用到反向传播和梯度下降的方式来更新权重。多层感知器的构造如图所示：多层感知器的“多层”结构可以从数据当中提取层次性的结构（每一层都可以从上一层当中提取一次特征），从而找到更好地模拟数据规律的方式。因此，具有单层无激活功能（或阶跃激活功能）的神经网络（即多层感知器）等同于线性回归。此外，线性回归可以使用封闭形式解决方案来解决。然而，随着MLP的结构更加复杂，封闭形式的解决方案不再管用，因此必须使用迭代解决方案，即通过逐步改进的方法来改善结果。这样的算法不一定会收敛，梯度下降就是一个经典的例子。MLP（深度学习）是一个高度参数化的模型。对于等式y = mx + c，m和c被称为参数，我们从数据和中推导出参数的值。方程的参数可以看作自由度，线性回归具有相对较少的参数，即具有较小的自由度。然而，更复杂的MLP具有更多的参数，也具有更大的自由度。虽然两者都是参数化模型，但MLP的优化策略（反向传播+梯度下降）比线性回归的优化策略（最小二乘法）复杂得多。从这个方面讲，神经网络可以看作是线性回归的复杂衍生物，多层感知器的高度参数化允许我们构建功能更加复杂的模型。

感知器学习 接下来我们看看感知器是如何与线性回归模型产生联系的。        感知器（Perceptrons）是用于二元分类问题的监督学习算法，二元分类器是二类问题的线性分类器。Mark I 感知器是感知器算法的第一个实现，感知器算法由Frank Rosenblatt于1957年在康奈尔航空实验室发明，感知器旨在成为一台机器，而不是一个程序，这台机器专为图像识别而设计：它有一个由400个光电池组成的阵列，随机连接到“神经元”，权重由电位器编码，并且在学习期间通过机器执行权重更新。在美国海军组织的1958年新闻发布会上，Rosenblatt发表了关于感知者的声明，这一声明引起了人工智能社区的激烈争论。根据罗森布拉特的声明，感知器是“电子计算机的胚胎，走路，说话，看，写，复制自己，并感受到它的存在。”单层感知器仅能够学习线性可分离的模式。1969年，一本名为Perceptrons的书表明，感知器网络不可能学习XOR功能。但是，如果我们使用非线性激活函数（而不是梯度函数），则可突破此限制。事实上，通过使用非线性激活函数，我们可以构建比XOR更复杂的函数（即使只有单层），如果我们添加更多隐藏层，则可以拓展处更复杂的功能，即我们接下来要介绍的多层感知器（深度学习）。我们回顾一下：1）感知器是生物神经元的简化模型。2）感知器是用于学习二元分类器的算法：将其输入映射到输出值的函数。3）在神经网络的背景下，感知器是使用Heaviside阶跃函数作为激活函数的人工神经元，感知器算法也称为单层感知器，以区别于多层感知器。4）Perceptron算法具有历史意义，但它为我们提供了一种拉近线性回归和深度学习之间差别的方法。5）单层感知器的学习过程如下所示，每加入一个数据点，感知器便会更新一次线性边界，类似于线性回归中的回归线。下图为感知器的示意图，f为阶跃函数，输出为二进制（0或1），i1-in为输入，Wi为各个输入的权重：

广义线性模型 在普通线性回归中，预测变量（x）的变化会导致响应变量（y）的变化，但是，当且仅当响应变量具有正态分布时才成立。在响应变量是正态分布时，有好多问题我们无法处理：1）响应变量总是为正且在很大范围内变化；2）预测变量的变化导致响应变量的几何变换，而不是连续变化（即两者间非线性关系）。广义线性回归是由普通线性回归延伸出的第二个模型，它满足：1）响应变量可以不是正态分布；2）允许响应变量不是随着预测变量线性变化。多项式回归 介绍了多元回归和GLM之后，让我们现在看一下我们可以从普通线性回归推断出的第三个模型——多项式回归。在多项式回归中，自变量x和因变量y之间的关系被表示为x的n次多项式的形式。多项式回归已被用于描述非线性现象，如组织的生长速度，湖泊沉积物中碳同位素的分布，以及疾病流行的进展。

多重线性回归 普通线性回归的第一个明显变体是多元线性回归。当只有一个特征时，我们有单变量线性回归，如果有多个特征，我们有多元线性回归。对于多元线性回归，模型可以以一般形式表示为：模型的训练即寻找最佳参数θ，以使模型最贴合数据。预测值与目标值之间的误差最小的直线称为最佳拟合线或回归线，这些误差被称为残差（Residuals）。可以通过从目标值到回归线的垂直线来可视化残差，如下图所示，灰色直线即回归线，紫色点为目标值，黄色垂直距离即残差。我们将整个模型的误差（即损失函数）定义为残差平方和，表示如下：最经典的多元线性回归问题是波士顿房价问题（Boston Housing Dataset）

线性回归 为什么从线性回归开始？因为即使在高中阶段，我们也开始接触到了这个概念。首先从“学习”这个概念讲起，在机器学习（监督学习）中，学习的过程即寻找一个数学方程式，从而使得每一个输入和输出都能够通过这个方程一一对应。在最简单的情境下，这个方程是线性的。什么是线性关系？线性关系指的是可以用一条直线表示的两个变量（x和y）之间的关系。许多现象都是线性关系，如双手拉橡皮所使用的力量和橡皮被拉伸的长度，我们可以用线性方程来表示如上关系：在线性关系中，改变自变量（x）的值会导致因变量（y）的值发生改变，因此线性关系可以用来预测诸如销售预估、用户行为分析等实际问题。线性关系如下图所示：线性回归问题意在寻找可以描述一个或多个特征（自变量）与目标值（因变量）之间关系的方程。如上图所示的线性回归问题，我们通常称之为普通线性回归，即最简单的线性回归。现在我们来考虑由简单线性回归引申出的三个问题：多元线性回归广义线性模型多项式回归

原文链接：https://bbs.huaweicloud.com/blogs/271147一、什么是逻辑回归？        回归是描述自变量和因变量之间相互依赖关系的统计分析方法。线性回归作为一种常见的回归方法，常用作线性模型（或线性关系）的拟合。        逻辑回归（logistic regression）虽然也称为回归，却不是一种模型拟合方法，而是一种简单的“二分类”算法。具有实现简单，算法高效等诸多优点。                                           图1.1   二维线性回归                                                    图1.2   三维线性回归1.1 线性回归（linear regression）       图1.1、1.2分别表示二维和三维线性回归模型，图1.1的拟合直接（蓝线）可表示为 y=ax+b，所有数据点（红点）到直线的总欧式距离最短，欧式距离常用作计算目标损失函数，进而求解模型；类似的，图1.2的所有数据点到二维平面的总欧式距离最短。所以线性回归模型通常可以表示为：其中θ表示模型系数。    1.2 逻辑回归（LR）        LR是一种简单的有监督机器学习算法，对输入x，逻辑回归模型可以给出 y<0 or y>0 的概率，进而推断出样本为正样本还是负样本。        LR引入sigmoid函数来推断样本为正样本的概率，输入样本 x 为正样本的概率可以表示为：P(y|x) = g(y)，其中 g() 为sigmoid函数，曲线图如图1.3所示，输出区间为0~1：图1.3    sigmoid曲线对于已知模型 θ 和样本 x，y=1的概率可以表示为：所以sigmoid尤其适用于二分类问题，当 g(y) > 0.5 时，表示 P(y=1|x) > 0.5，将其判为正样本，对应 y>0 ；反之，当 g(y) < 0.5 时，表示 P(y=1|x) < 0.5，将其判为负样本，对应 y<0。  1.3 LR损失函数     LR采用对数损失函数，对于训练集x∈S，损失函数可以表示为（参考https://zhuanlan.zhihu.com/p/44591359）：     梯度下降算法是LR模型的经典解法之一，模型迭代更新的表达式如下：其中l()为目标损失函数，本质为平均对数损失函数。S'为批处理数据集(大小为batchsize)，通过批处理方式引入随机扰动，使得模型权重更加快速逼近最优值。α为学习率，直接影响模型的收敛速度，学习率过大会导致loss左右震荡无法达到极值点，学习率太小会导致loss收敛速度过慢，长时间找不到极值点。    二、纵向联邦学习场景下的LR        关于纵向联邦学习的介绍已经屡见不鲜，市面上也涌现出很多优秀的产品，比如FATE、TICS等。纵向联邦可以实现多用户在不暴露己方数据的前提下，共享数据和特征，训练出精度更高的模型，对于金融和政务等众多行业具有重要意义。图2.1 纵向联邦LR2.1 LR的纵向联邦实现         纵向联邦学习的参与方都是抱着共享数据、不暴露己方数据的目的加入到联邦中，所以任何敏感数据都必须经过加密才能出己方信任域（图2.1，参考https://arxiv.org/pdf/1711.10677.pdf），这就引入了同态加密算法。同态加密为密文计算提供了可行性，同时也一定程度上影响了机器学习算法的性能。常见的同态加密库包括seal、paillier等。         纵向联邦场景下梯度计算公式如下：LR的纵向联邦流程如图2.2所示，host表示只有特征的一方，guest表示包含标签的一方。图 2.2 纵向联邦LR算法实现流程在训练开始之前，作业双方需要交换同态公钥。每轮epoch（迭代）的batch（一轮batchsize的计算为一个batch）循环中，包含calEncryptedU-->calEncryptedGradient-->decryptGradient-->updateLrModel四步，guest和host都需要按此顺序执行一遍（  流程图中只体现了guest作为发起方的执行流程）。A2步骤中梯度加随机噪声的目的是为了防止己方U泄露，造成安全问题。      由于同态加密计算只支持整数、浮点数的加法和乘法，所以将1.3中的模型迭代公式中的指数部分表示成泰勒表达式形式：

TensorFlow 实现线性回归1.    实验介绍1.1.   关于本实验本实验为TensorFlow线性回归的一个实际案例即房价预测。1.2. 实验目的理解线性回归。理解如何利用TensorFlow做预测。1.3. 实验介绍本实验通过一个预测房屋价格的实例来讲解利用线性回归预测房屋价格，以及在tensorflow中如何实现。平时常用的房价预测数据集为波士顿房价数据集，本实验采用的是北京的房价数据集，更贴近国人的生活。1.4. 实验步骤                              步骤 1     步骤1登陆华为云。                              步骤 2     点击右上方的控制台。                              步骤 3     选择弹性云服务器，网页中会显示该弹性云的可进行的操作，选择远程登录。即登录到弹性云服务器。                              步骤 4     输入指令ll，查看当前目录下的文件。                              步骤 5     输入命令vi house_price.py，创建新的Python脚本。                              步骤 6     输入命令i,进入编辑模式开始编辑，输入脚本内容。                              步骤 7     输入命令 :wq!,保存并退出。                              步骤 8     输入命令cat house_price.py查看代码。                              步骤 9     运行测试。输入命令：python3 house_price.py。 2.    实验过程2.1. 设置编码说明# coding:utf-82.2. 导入模块#载入此项目所需的库from __future__ import print_function, divisionimport tensorflow as tfimport pandas as pdimport numpy as npimport matplotlib.pyplot as pltimport seaborn2.3. 导入数据该实验数据来源为：https://github.com/cunxi1992/boston_housing中的bj_housing2.csv文件。读取数据：train = pd.read_csv("bj_housing2.csv")更多的技术内容，请访问腾科公司网站 www.togogo.net2.4. 定义参数train = train[train['Area'] < 12000]train_X = train['Area'].values.reshape(-1, 1)train_Y = train['Value'].values.reshape(-1, 1)n_samples = train_X.shape[0] # 定义参数，设置学习率learning_rate = 2# 设置训练次数training_epochs = 1000# 设置多少次显示一次display_step = 502.5. 定义占位符# 定义X,Y占位符X = tf.placeholder(tf.float32)Y = tf.placeholder(tf.float32) # 使用Variable定义的学习参数W = tf.Variable(np.random.randn(), name="weight", dtype=tf.float32)b = tf.Variable(np.random.randn(), name="bias", dtype=tf.float32)2.6. 构建正向传播结构# 构建正向传播结构pred = tf.add(tf.multiply(W, X), b)#损失函数cost = tf.reduce_sum(tf.pow(pred-Y, 2)) / (2 * n_samples)# ʹ使用梯度下降优化器optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)2.7. 初始化# 激活Initinit = tf.global_variables_initializer() # 启动session，初始化变量with tf.Session() as sess:sess.run(init)2.8. 启动循环#启动循环开始训练    for epoch in range(training_epochs):        for (x, y) in zip(train_X, train_Y):            sess.run(optimizer, feed_dict={X: x, Y: y})#显示训练中的详细信息        if (epoch + 1) % display_step == 0:            c = sess.run(cost, feed_dict={X: train_X, Y: train_Y})            print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.3f}".format(c), "W=", sess.run(W), "b=", sess.run(b))    #显示训练中的详细信息     print("Optimization Finished!")    training_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y})    print("Training cost=", training_cost, "W=", sess.run(W), "b=", sess.run(b), '\n')2.9. 展示训练结果    #展示训练结果    plt.plot(train_X, train_Y, 'ro', label="Original data")    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label="Fitted line")    plt.legend()plt.show()2.10.   实验结果输出结果：Epoch: 0050 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0100 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0150 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0200 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0250 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0300 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0350 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0400 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0450 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0500 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0550 cost= 16308.796 W= 1.8889627 b= 155.08276Epoch: 0600 cost= 16308.796 W= 1.8889627 b= 155.08276……3.    实例描述本实验利用网上已有的北京房价数据集预测了北京的房价，实现了TensorFlow的线性回归应用。更多的技术内容，请访问腾科公司网站 www.togogo.net