精华内容
下载资源
问答
  • , figsize=(12, 8)) #save_fig("scatter_matrix_plot") #找到最好的属性(收入中位数),单独拉出来 housing.plot(kind="scatter", x="median_income", y="median_house_value", alpha=0.1) plt.axis([0, 16, 0, ...

    前提条件:

    1、有一些python编程经验。
    2、熟悉python主要科学库,特别是:numpy,pandas和matplotlib。
    3、最好使用Jupyter 编程。(没有的话,建议下载Anaconda。里面有。)

    一、下载数据:

    1、 下载一个压缩文件housing.tgz即可,其包含housing.csv(已经包含书有数据。),用 tax xzf housing.tgz 来解压提取CSV文件。

    import os
    import tarfile
    import urllib.request
    
    DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml2/master/"
    HOUSING_PATH = os.path.join("datasets", "housing")
    HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing.tgz"
    
    def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):
        if not os.path.isdir(housing_path):
            os.makedirs(housing_path)
        tgz_path = os.path.join(housing_path, "housing.tgz")
        urllib.request.urlretrieve(housing_url, tgz_path)
        housing_tgz = tarfile.open(tgz_path)
        housing_tgz.extractall(path=housing_path)
        housing_tgz.close()
    

    之后应用函数就好了。Jupyter 最好用谷歌浏览器,搞不好会报错(没有网站访问权限)。

    fetch_housing_data()
    

    2、使用pandas加载数据,返回包含所用数据的DF 对象。

    import pandas as pd
    
    def load_housing_data(housing_path=HOUSING_PATH):
        csv_path=os.path.join(housing_path,"housing.csv")
        return pd.read_csv(csv_path)
    load_housing_data(HOUSING_PATH)# 查看信息。
    

    查看数据结构:

    # 住房信息
    housing = load_housing_data()
    housing.head()
    housing.info()
    #统计学数据
    housing.describe()
    #每个数值属性的直方图
    %matplotlib inline
    import matplotlib.pyplot as plt
    
    housing.hist(bins=50,figsize=(20,15))
    plt.show()
    

    3、创建测试集(一般为数据集的百分之20,数据集越大,比例越小。)

    # to make this notebook's output identical at every run
    import numpy as np
    np.random.seed(42)
    # For illustration only. Sklearn has train_test_split()
    def split_train_test(data, test_ratio):
        shuffled_indices = np.random.permutation(len(data))
        test_set_size = int(len(data) * test_ratio)
        test_indices = shuffled_indices[:test_set_size]
        train_indices = shuffled_indices[test_set_size:]
        return data.iloc[train_indices], data.iloc[test_indices]
    train_set, test_set = split_train_test(housing, 0.2)
    len(train_set)
    len(test_set)
    
    
    from zlib import crc32
    
    def test_set_check(identifier, test_ratio):
        return crc32(np.int64(identifier)) & 0xffffffff < test_ratio * 2**32
    
    def split_train_test_by_id(data, test_ratio, id_column):
        ids = data[id_column]
        in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio))
        return data.loc[~in_test_set], data.loc[in_test_set]
    import hashlib
    
    def test_set_check(identifier, test_ratio, hash=hashlib.md5):
        return hash(np.int64(identifier)).digest()[-1] < 256 * test_ratio
    
    
    def test_set_check(identifier, test_ratio, hash=hashlib.md5):
        return bytearray(hash(np.int64(identifier)).digest())[-1] < 256 * test_ratio
    #使用行索引做ID
    housing_with_id = housing.reset_index()   # adds an `index` column
    train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "index")
    
    housing_with_id["id"] = housing["longitude"] * 1000 + housing["latitude"]
    train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "id")
    
    test_set.head()
    

    4、用Scikit-Learn 随机拆分 和 分层抽样出的数据测试集:

    #随机拆分:
    from sklearn.model_selection import train_test_split
    
    train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)
    #观看效果:
    test_set.head()
    housing["median_income"].hist()
    housing["income_cat"] = pd.cut(housing["median_income"],
                                   bins=[0., 1.5, 3.0, 4.5, 6., np.inf],
                                   labels=[1, 2, 3, 4, 5])
    
    housing["income_cat"].value_counts()
    housing["income_cat"].hist()
    
    #分层抽样:
    from sklearn.model_selection import StratifiedShuffleSplit
    
    split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
    for train_index, test_index in split.split(housing, housing["income_cat"]):
        strat_train_set = housing.loc[train_index]
        strat_test_set = housing.loc[test_index]
    #效果:
    #收入类别比例:
    strat_test_set["income_cat"].value_counts() / len(strat_test_set)
    housing["income_cat"].value_counts() / len(housing)
    

    5、接下来对三种测试集进行比较。

    def income_cat_proportions(data):
        return data["income_cat"].value_counts() / len(data)
    
    train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)
    
    compare_props = pd.DataFrame({
        "Overall": income_cat_proportions(housing),
        "Stratified": income_cat_proportions(strat_test_set),
        "Random": income_cat_proportions(test_set),
    }).sort_index()
    compare_props["Rand. %error"] = 100 * compare_props["Random"] / compare_props["Overall"] - 100
    compare_props["Strat. %error"] = 100 * compare_props["Stratified"] / compare_props["Overall"] - 100
    compare_props
    

    得到结果之后,只有随机的会有一定的偏差。我们可以将其删除,使数据恢复原样:

    for set_ in (strat_train_set, strat_test_set):
        set_.drop("income_cat", axis=1, inplace=True)
    

    **二、数据探索

    前提(为了不损坏数据,copy一下吧。)**

    housing = strat_train_set.copy()
    

    1、将地理数据可视化:

    #地理散点图。
    housing.plot(kind="scatter", x="longitude", y="latitude")
    #save_fig("bad_visualization_plot")
    
    #突出高密度区域的更好的可视化。
    housing.plot(kind="scatter",x="longitude",y="latitude",alpha=0.1)
    
    
    
    #加州房价:红(贵,蓝(便宜,圆圈大小代表人口密度。
    housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.4,
                 s=housing["population"]/100, label="population", figsize=(10,7),
                 c="median_house_value", cmap=plt.get_cmap("jet"), colorbar=True,
                 sharex=False)
    plt.legend()
    #save_fig("housing_prices_scatterplot")
    
    #加州房价:红(贵,蓝(便宜,圆圈大小代表人口密度。
    
    

    2、寻找相关性:

    #计算每对属性之间的相关属性。
    corr_matrix = housing.corr()
    
    #查看相关性
    corr_matrix["median_house_value"].sort_values(ascending=False)
    
    #每个数值属性的直方图,和每个属性相对于其他属性的散布矩阵
    # from pandas.tools.plotting import scatter_matrix # For older versions of Pandas
    from pandas.plotting import scatter_matrix
    
    attributes = ["median_house_value", "median_income", "total_rooms",
                  "housing_median_age"]
    scatter_matrix(housing[attributes], figsize=(12, 8))
    #save_fig("scatter_matrix_plot")
    
    #找到最好的属性(收入中位数),单独拉出来
    
    housing.plot(kind="scatter", x="median_income", y="median_house_value",
                 alpha=0.1)
    plt.axis([0, 16, 0, 550000])
    save_fig("income_vs_house_value_scatterplot")
    
    

    3、试验不同属性的组合(特征提取):

    #  创建三个新属性
    housing["rooms_per_household"] = housing["total_rooms"]/housing["households"]
    housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"]
    housing["population_per_household"]=housing["population"]/housing["households"]
    
    #查看相关矩阵
    corr_matrix = housing.corr()
    corr_matrix["median_house_value"].sort_values(ascending=False)
    
    #可视化
    housing.plot(kind="scatter", x="rooms_per_household", y="median_house_value",
                 alpha=0.2)
    plt.axis([0, 5, 0, 520000])
    plt.show()
    housing.describe()
    

    三、数据准备

    先回到一个干净的训练集(copy())^ ^

    housing = strat_train_set.drop("median_house_value", axis=1) # drop labels for training set
    housing_labels = strat_train_set["median_house_value"].copy()
    

    1、数据清理(对残缺的数据,我进行的是补充完整训练数据的中位数。):

    #前后对比。
    sample_incomplete_rows = housing[housing.isnull().any(axis=1)].head()
    sample_incomplete_rows
    median = housing["total_bedrooms"].median()
    sample_incomplete_rows["total_bedrooms"].fillna(median, inplace=True)
    sample_incomplete_rows
    

    2、Scikit-Learn的设计:

    
    from sklearn.impute import SimpleImputer
    imputer = SimpleImputer(strategy="median")
    housing_num = housing.drop("ocean_proximity", axis=1)
    imputer.fit(housing_num)
    imputer.statistics_
    housing_num.median().values
    X = imputer.transform(housing_num)
    housing_tr = pd.DataFrame(X, columns=housing_num.columns ,index=housing_num.index )
    housing_tr.loc[sample_incomplete_rows.index.values]
    imputer.strategy
    housing_tr = pd.DataFrame(X, columns=housing_num.columns,
                              index=housing_num.index)
    
    housing_tr.head()
    
    

    3、处理文本和分类属性:
    前面我们只处理了数值属性。现在看一下文本属性。

    housing_cat = housing[["ocean_proximity"]]
    housing_cat.head(10)
    
    #文本转数字
    from sklearn.preprocessing import OrdinalEncoder
    ordinal_encoder =OrdinalEncoder()
    housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)
    housing_cat_encoded[:10]
    
    #获取类别 列表。
    ordinal_encoder.categories_
    
    #传化为独热向量
    from sklearn.preprocessing import OneHotEncoder
    cat_encoder = OneHotEncoder()
    housing_cat_1hot = cat_encoder.fit_transform(housing_cat)
    housing_cat_1hot
    
    #将上面的输出的稀疏矩阵 转换成 numpy数组
    housing_cat_1hot.toarray()
    
    #查看一下
    cat_encoder.categories_  
    

    4、自定义转换器

    #添加组合后的属性
    from sklearn.base import BaseEstimator,TransformerMixin
    rooms_ix , bedrooms_ix, population_ix , households_ix =3,4,5,6
    class  CombinedAttributesAdder(BaseEstimator, TransformerMixin ):
        def __init__ (self, add_bedrooms_per_room = True):
            self.add_bedrooms_per_room=add_bedrooms_per_room
        def fit(self,X, y = None):
            return self
        def transform(self , X):
            rooms_per_household = X [: , rooms_ix] / X[:,households_ix]
            population_per_household = X[:,population_ix] / X [:, households_ix]
            if self.add_bedrooms_per_room:
                bedrooms_per_room = X[:,bedrooms_ix] / X[:,rooms_ix]
                return np.c_[X,rooms_per_household , population_per_household,bedrooms_per_room ]
            else:
                return np.c_[X,rooms_per_household, population_per_household ]
    attr_adder = CombinedAttributesAdder(add_bedrooms_per_room= False)
    housing_extra_attribs= attr_adder.transform(housing.values)
    

    5、特征缩放:

    col_names = "total_rooms", "total_bedrooms", "population", "households"
    rooms_ix, bedrooms_ix, population_ix, households_ix = [
        housing.columns.get_loc(c) for c in col_names] # get the column indices
    
    housing_extra_attribs = pd.DataFrame(
        housing_extra_attribs,
        columns=list(housing.columns)+["rooms_per_household", "population_per_household"],
        index=housing.index)
    housing_extra_attribs.head()
    

    6、转换流水线:
    (数据的转换需要正确的顺序来执行)

    from sklearn.pipeline import Pipeline
    from sklearn.preprocessing import StandardScaler
    
    num_pipeline = Pipeline([
            ('imputer', SimpleImputer(strategy="median")),
            ('attribs_adder', CombinedAttributesAdder()),
            ('std_scaler', StandardScaler()),
        ])
    
    housing_num_tr = num_pipeline.fit_transform(housing_num)
    
    
    #将所有转换应用到房屋数据
    from sklearn.compose import ColumnTransformer
    
    num_attribs = list(housing_num)
    cat_attribs = ["ocean_proximity"]
    
    full_pipeline = ColumnTransformer([
        ("num",num_pipeline , num_attribs ),
        ("cat" , OneHotEncoder(),cat_attribs ),
    ])
    housing_prepared = full_pipeline.fit_transform(housing)
    
    housing_prepared
    housing_prepared.shape
    

    四、选择和训练模型

    开始准备机器学习算法:
    一共训练了线性回归模型,决策树和随机森林。训练之后用测试集评估看那个泛化效果更好。
    1、训练和评估训练集:

    #训练线性回归模型。
    from sklearn.linear_model import LinearRegression
    
    lin_reg = LinearRegression()
    lin_reg.fit(housing_prepared,housing_labels)
    
    #训练集实例预测(大概率不太准)
    some_data =housing.iloc[:5]
    some_labels = housing_labels.iloc[: 5]
    some_data_prepared = full_pipeline.transform(some_data)
    print("Predictions:",lin_reg.predict(some_data_prepared))
    #使用skl来训练。
    from sklearn.metrics import mean_squared_error
    housing_predictions = lin_reg.predict(housing_prepared)
    lin_mse  = mean_squared_error(housing_labels, housing_predictions)
    lin_rmse = np.sqrt(lin_mse)
    lin_rmse
    
    

    但是这个结果也并不是太好看(68628.198)有点大。让我们再看一下决策树:

    from sklearn.tree  import DecisionTreeRegressor      #决策树模型
    
    tree_reg = DecisionTreeRegressor()
    tree_reg.fit(housing_prepared, housing_labels)
    housing_predictions = tree_reg.predict(housing_prepared)
    tree_mse = mean_squared_error(housing_labels,housing_predictions)
    tree_rmse = np.sqrt(tree_mse)
    tree_rmse 
    

    结果为(0.0) 大概严重过拟合了。

    2、交叉验证更好的评估:

    #交叉验证 过拟合
    from sklearn.model_selection import cross_val_score
    scores = cross_val_score(tree_reg,housing_prepared , housing_labels , 
                            scoring="neg_mean_squared_error", cv=10)
    tree_rmse_scores = np.sqrt(-scores)
    
    def display_scores(scores):
        print("Scores:",scores)
        print("Mean:", scores.mean())
        print("Standard deviation:", scores.std())
        
    display_scores(tree_rmse_scores)
    
    lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels,
                                 scoring="neg_mean_squared_error", cv=10)
    lin_rmse_scores = np.sqrt(-lin_scores)
    display_scores(lin_rmse_scores)       #线性回归模型
    

    之后你会发现,决策树确实是过拟合了,而且表现比线性回归还有糟糕。让我们再试试随机森林:

    #随机森林
    from sklearn.ensemble import RandomForestRegressor
    forest_reg = RandomForestRegressor()
    forest_reg.fit(housing_prepared,housing_labels)
    
    housing_predictions = forest_reg.predict(housing_prepared)
    forest_mse = mean_squared_error(housing_labels, housing_predictions)
    forest_rmse = np.sqrt(forest_mse)
    forest_rmse
    #这个结果就好多了。
    from sklearn.model_selection import cross_val_score
    
    forest_scores = cross_val_score(forest_reg, housing_prepared, housing_labels,
                                    scoring="neg_mean_squared_error", cv=10)
    forest_rmse_scores = np.sqrt(-forest_scores)
    display_scores(forest_rmse_scores)
    
    

    五、微调模型:

    1、网格搜索:
    调整超参数:

    #找出超参数值的最佳组合。
    
    from sklearn.model_selection import GridSearchCV    #微调超参数。(网格搜素。
    
    param_grid = [
        # try 12 (3×4) combinations of hyperparameters
        {'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6, 8]},
        # then try 6 (2×3) combinations with bootstrap set as False
        {'bootstrap': [False], 'n_estimators': [3, 10], 'max_features': [2, 3, 4]},
      ]
    
    forest_reg = RandomForestRegressor(random_state=42)
    # train across 5 folds, that's a total of (12+6)*5=90 rounds of training 
    grid_search = GridSearchCV(forest_reg, param_grid, cv=5,
                               scoring='neg_mean_squared_error',
                               return_train_score=True)
    grid_search.fit(housing_prepared, housing_labels)
    
    grid_search.best_params_
    
    grid_search.best_estimator_
    
    #所有组合:
    cvres = grid_search.cv_results_          #得到评估分数。
    for mean_score ,params in zip(cvres["mean_test_score"],cvres["params"]):
        print(np.sqrt(-mean_score),params)
    

    2、随机搜索:(适合那种超参数比较大范围的)。

    #随机搜索。
    from sklearn.model_selection import RandomizedSearchCV
    from scipy.stats import randint
    
    param_distribs = {
            'n_estimators': randint(low=1, high=200),
            'max_features': randint(low=1, high=8),
        }
    
    forest_reg = RandomForestRegressor(random_state=42)
    rnd_search = RandomizedSearchCV(forest_reg, param_distributions=param_distribs,
                                    n_iter=10, cv=5, scoring='neg_mean_squared_error', random_state=42)
    rnd_search.fit(housing_prepared, housing_labels)
    
    rnd_search.best_params_
    
    #所有结果:
    cvres = rnd_search.cv_results_
    for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):
        print(np.sqrt(-mean_score), params)
    

    3、分析最佳模型及其误差:

    feature_importances = grid_search.best_estimator_.feature_importances_ 
    feature_importances      #分析最佳模型及其误差。
    

    将重要性分数显示在对应属性旁边:

    extra_attribs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]
    #cat_encoder = cat_pipeline.named_steps["cat_encoder"] # old solution
    cat_encoder = full_pipeline.named_transformers_["cat"]
    cat_one_hot_attribs = list(cat_encoder.categories_[0])
    attributes = num_attribs + extra_attribs + cat_one_hot_attribs
    sorted(zip(feature_importances, attributes), reverse=True)
    

    4、通过测试集评估系统:
    到现在,我们终于有了一个还不错的系统。来让我们进行最后的评估,成败在此一举。
    评估最终模型

    #通过测试集评估最终模型系统
    final_model = grid_search.best_estimator_
    
    x_test = strat_test_set.drop("median_house_value", axis=1)
    y_test = strat_test_set["median_house_value"].copy()
    
    x_test_prepared = full_pipeline.transform(x_test)
    final_predictions = final_model.predict(x_test_prepared)
    
    final_mse = mean_squared_error(y_test , final_predictions)
    final_rmse =  np.sqrt(final_mse)  
    
    final_rmse
    

    结果还不错,但是存在的泛化误差的危害性还是比较大的。
    为此计算泛化误差的0.95置信区间:

    from scipy import stats     #计算泛化误差0.95的置信区间
    
    confidence = 0.95
    squared_errors = (final_predictions - y_test) ** 2
    np.sqrt(stats.t.interval(confidence, len(squared_errors) - 1,
                             loc=squared_errors.mean(),
                             scale=stats.sem(squared_errors)))
    

    六、启动!!

    #准备和预测的完整数组
    full_pipeline_with_predictor = Pipeline([
            ("preparation", full_pipeline),
            ("linear", LinearRegression())
        ])
    
    full_pipeline_with_predictor.fit(housing, housing_labels)
    full_pipeline_with_predictor.predict(some_data)
    

    保存训练好的模型,以后还能用。^^

    #保存训练好的模型
    my_model = full_pipeline_with_predictor
    import joblib
    joblib.dump(my_model, "my_model.pkl") # DIFF
    #...
    my_model_loaded = joblib.load("my_model.pkl") # DIFF
    

    结束语:

    我是跟着一本《机器学习实战》学习的,以上基本上是上面的内容。以下会提及。
    鄙人不才,分析不是很全面,如有一些错误,请评论指正,感谢!
    完整代码: 这个是我敲的
    或者:原作者敲的
    最后:
    Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition, 作者: Aurelien Geron(法语) , 又 O Reilly 出版, 书号 978-1-492-03264-9。
    建议买一本,很不错。🆗

    展开全文
  • 其次,建立和尾与和数的转移概率矩阵,基于马尔科夫链的预测法,得出下期和尾与和数各状态概率矩阵,从中挑选出概率最大几项作为下期预测的和尾及和数,为投资者提供更好的投资方案。关键词:转移概率矩阵;状态概率...

    张思思  曾华

    (中南大学土木建筑学院,湖南长沙  410012)

    摘要:本文首先对“体彩排列三”中的和数与和尾上近1074期的出号数字进行统计,利用马尔可夫链,求得其相应的转移矩阵。其次,建立和尾与和数的转移概率矩阵,基于马尔科夫链的预测法,得出下期和尾与和数各状态概率矩阵,从中挑选出概率最大几项作为下期预测的和尾及和数,为投资者提供更好的投资方案。

    关键词:转移概率矩阵;状态概率矩阵;马尔科夫预测法

    一、“体彩排列三”的基本知识

    购买"体彩排列3"时,由购买者从000-999的数字中选取1个3位数为投注号码进行投注。彩票购买人购买彩票时关注的概念有:

    1. 和值:即下期彩票三个数字之和;

    2. 和尾:即和值中的第二位数值;

    3. 跨度:下期彩票三个数字中的最大数与最小数之差;

    4. 胆码:下期可能出现的出号;

    5. 组合:彩票三个数字的不同组合;

    二、建立转移概率矩阵

    2.1问题的分析

    由于各期的体育彩票出号均为相互独立,且百位、十位和各位上的数字也互不影响,均为相互独立。在事件的发展过程中,每次状态的转移都仅与前一时刻的状态有关,而与过去的状态无关,或者说状态转移过程是无后效性的,则可知这样的状态转移过程是马尔可夫过程。

    根据过去近1000期的体育彩票“排列三”的出号,可分别将百位、十位和各位上的1000个数据统计出来,在事件的发展变化过程中,从某一种状态出发,下一时刻转移到其它状态的可能性,称为状态转移概率。

    2.2状态转移矩阵的建立

    (1)状态转移概率:在事件的发展变化过程中,从某一种状态出发,下一时刻转移到其它状态的可能性,称为状态转移概率。由状态Ei转为状态Ej的状态转移概率为:

    (2)状态转移概率矩阵:假定某一个事件的发展过程有n个可能的状态,即。记为从状态 转变为状态的状态转移概率 ,则其状态转移概率矩阵:

    其中,

    2.3状态转移矩阵的求解

    经查阅资料可得近1074期的号码历史数据,知对和尾上的数字均为0—9内的数字间的相互转移,假设对于数字0—9,其对应的转移状态用 来表示,则从状态转移到 状态的个数为 , 为状态 的个数,概率为 ,可知

    (4.2.1)

    因此,只要统计出从 状态转移到状态的个数为 ,则可求得从 状态转移到 状态的转移概率。同理,对于和数上的数字即是在0—27内转移。

    三、预测和尾与和数

    3.2马尔科夫预测法

    马尔可夫(Markov)预测法,是一种预测事件发生的概率的方法。它是基于马尔可夫链,根据事件的目前状况预测其将来各个时刻(或时期)变动状况的一种预测方法。

    通过对历史数据进行统计,可求出和尾和和数的转移概率矩阵,由此,可通过当期的数据求出下期将出现的数字的状态概率矩阵,筛选出概率较大的作为预测结果。

    3.2.1 马尔科夫预测法的建立

    (1)状态概率:表示事件在初始(k=0)状态为已知的条件下,经过k次状态转移后,在第k 个时刻(时期)处于状态 的概率。 且:

    根据马尔可夫过程的无后效性及Bayes条件概率公式,有:

    (j=1,2,n)

    (2)状态概率递推公式:

    记行向量  ,则由上式可以得到逐次计算状态概率的递推公式:

    式中, 为初始状态概率向量。

    (3)第k个时刻(时期)的状态概率预测

    如果某一事件在第0个时刻(或时期)的初始状态已知,即 已知,则利用递推公式,就可以求得它经过k次状态转移后,在第k个时刻(时期)处于各种可能的状态的概率,即,从而就得到该事件在第k个时刻(时期)的状态概率预测

    3.2.2 马尔科夫预测法的求解

    通过MATLAB程序,取近1074组数据,可得到和尾与和数下一期的各状态的概率如下所示:

    和尾的状态概率矩阵:

    P =[0.1122,0.1224,0.1020,0.0918,0.0918,0.1429,0.1020,0.1122,0.0408,0.0816]

    和数的状态概率矩阵:

    P=[0,0,0,0.0185,0,0.0185,0.0185,0.0185,0,0.0370,0.0556,0.0741,0.0741,0.0556,0.0741,0.1481,0.0741,0.1111 0.0185,0.0556,0.0926,0.0185,0,0,0.0185,0.0185,0,0]

    根据以上状态概率,分别选取和尾和和数概率最大的前三个数作为下期的预测值,即:

    下期看好和尾:5、1、0、7、2

    下期看好和数:20、11、12、13、16

    展开全文
  • Some animals did disappear bu 市场预测中的定量预测方法有()。 在Word 2003的编辑状态下,若要对当前文档的表格设置表格线的宽度,应当使用“格式”菜单的______命令。 男性,20岁,站立较久或行走过多感觉...

    it took 5 million years for the planet to recover. Yet 60 million years ago, there was another huge amount of volcanic activity and global warming but no mass extinction. Some animals did disappear bu

    市场预测中的定量预测方法有()。

    在Word 2003的编辑状态下,若要对当前文档中的表格设置表格线的宽度,应当使用“格式”菜单中的______命令。

    男性,20岁,站立较久或行走过多感觉阴囊下坠3个月余,休息、平卧后症状消失。最可能的诊断是

    固定单价合同适用于______的项目。

    A.胰岛素B.肾上腺素C.甲状腺素D.甲状旁腺素E.胰高血糖素抑制糖异生作用

    配对资料秩和检验的基本思想是,如果检验假设成立,对样本来说

    根据《会计法》的规定,单位内部的会计工作管理应由( )负责。

    置备鸠尾的目的是()。

    根据《会计法》的规定,单位内部的会计工作管理应由( )负责。

    首创“媒介”一词的人是( )

    在页式管理中,存储页面表的作用是记录内存页面的分配情况,存储页面表的结构有三种方法:、空闲页面表和。

    配对资料秩和检验的基本思想是,如果检验假设成立,对样本来说

    包块进行性增大的是()。

    市场预测中的定量预测方法有()。

    A.胰岛素B.肾上腺素C.甲状腺素D.甲状旁腺素E.胰高血糖素抑制糖异生作用

    Read the following text, Choose the best word(s) for each numbered blank and mark [A],[B], [C]or[D] on ANSWER SHEET 1. 12()

    ______ deals with the relationship between the linguistic element and the non-linguistic world of experience. It means what a linguistic form refers to in the physical world.

    Intellect is to the mind()sight is to the body.

    (71~75题共用备选答案)核染色质聚集,有核仁或消失,胞浆较多,呈淡红色,浆内有嗜苯胺蓝颗粒,核浆比约为1:1

    简述股东的权利。

    2003年,医药工业总的盈利比2002年增长( )。

    求1996+1997+1998+1999的值是()

    由于大规模的国际资本流动对一国经济既有积极影响,又有消极影响,因此对国际资本流动进行必要的管理是必要的,下列属于各国对国际资本流动进行管理所采取的措施的是。

    求1996+1997+1998+1999的值是()

    完成曼彻斯特编码的是10MB/s以太网的( )层。

    According to Searle,acts fall into five general categories, i.e. there are five general types of things we do with language.

    当交货数量与合同不符时,双方又不在同一城市,采购方应先把货物接受下来并负责保管,然后将详细情况和处理意见在到货后的( )天内通知对方。

    固定单价合同适用于______的项目。

    it took 5 million years for the planet to recover. Yet 60 million years ago, there was another huge amount of volcanic activity and global warming but no mass extinction. Some animals did disappear bu

    求1996+1997+1998+1999的值是()

    在SQL Server 2008中,有系统数据库master、model、msdb、tempdb和用户数据库。下列关于系统数据库和用户数据库的备份策略,最合理的是( )。

    硬线立体构成的空间组合有发射式、重复式、类似式、______等。

    生物群落是指群居在一起的生物有规律地组合,在环境相似的不同地段( )出现的单元。

    网络沉淀了很多流行语,如“土豪,我们做朋友吧”“待我长发及腰,少年娶我可好”“高端大气上档次,低调奢华有内涵”“吓死宝宝了”“世界这么大我想去看看”,这些流行语背后,都有一段令人或共鸣或讽刺的故事,这蕴含的哲理是( )。

    展开全文
  • 股票交易者对于收盘价的预测很感兴趣。常识告诉我们,这个价格应该接近于某种均值。算数平均值和加权平均值都是在数值分布寻找中心点的方法。然而,它们对于异常值(outlier)既不鲁棒也不敏感。举例来说,如果...

    本章将介绍NumPy的常用函数。具体来说,我们将以分析历史股价为例,介绍怎样从文件中载入数据,以及怎样使用NumPy的基本数学和统计分析函数。这里还将学习读写文件的方法,并尝试函数式编程和NumPy线性代数运算。

    第三章 常用函数

    3.9 统计分析

    股票交易者对于收盘价的预测很感兴趣。常识告诉我们,这个价格应该接近于某种均值。算数平均值和加权平均值都是在数值分布中寻找中心点的方法。然而,它们对于异常值(outlier)既不鲁棒也不敏感。举例来说,如果我们有一个高达100万美元的收盘价,这将影响到我们的计算结果。

    3.10 动手实践:简单统计分析

    我们可以用一些阈值来除去异常值,但其实有更好的方法,那就是中位数。将各个变量值按大小顺序排列起来,形成一个数列,居于数列中间位置的那个数即为中位数。例如,我们有1、 2、3、 4、 5这5个数值,那么中位数就是中间的数字3。下面是计算中位数的步骤。

    • (1) 计算收盘价的中位数。创建一个新的Python脚本文件,命名为simplestats.py。你已经知道如何从CSV文件中读取数据到数组中了,因此只需要复制一行代码并确保只获取收盘价数据即可,如下所示:
    c=np.loadtxt('data.csv', delimiter=',', usecols=(6,), unpack=True)
    
    • (2) median函数将帮助我们找到中位数。我们调用它并立即打印出结果。添加下面这行代码:
    print("median =", np.median(c))
    

    这段代码的输出内容如下:

    median = 352.055
    
    • (3) 既然这是我们首次使用median函数,我们来检查一下结果是否正确。这可不是因为我们多疑!当然,我们可以将整个数据文件浏览一遍并人工找到正确的答案,但那样太无趣了。我们将对价格数组进行排序,并输出排序后居于中间位置的值,这也就是模拟了寻找中位数的算法。 msort函数可以帮我们完成第一步。我们将调用这个函数,获得排序后的数组,并输出结果。
    sorted_close = np.msort(c)
    print("sorted =", sorted_close)
    

    这段代码的输出内容如下:

    sorted = [336.1  338.61 339.32 342.62 342.88 343.44 344.32 345.03 346.5  346.67
     348.16 349.31 350.56 351.88 351.99 352.12 352.47 353.21 354.54 355.2
     355.36 355.76 356.85 358.16 358.3  359.18 359.56 359.9  360.   363.13]
    

    太好了,代码生效了!现在,我们来获取位于中间的那个数字:

    N = len(c)
    print("middle =", sorted_close[int((N - 1)/2)])
    

    输出如下:

    middle = 351.99
    
    • (4) 咦,这个值和median函数给出的值不一样,这是怎么回事?经过仔细观察我们发现,median函数返回的结果甚至根本没有在我们的数据文件里出现过。这就更奇怪了!在给NumPy团队提交bug报告之前,我们先来看下文档。原来这个谜团很容易解开。原因就在于我们的简单算法模拟只对长度为奇数的数组奏效。对于长度为偶数的数组,中位数的值应该等于中间那两个数的平均值。因此,输入如下代码:
    print("average middle =", (sorted_close[int(N /2)] + sorted_close[int((N - 1) / 2)]) / 2)
    

    输出结果如下:

    average middle = 352.055
    

    成功了!

    • (5) 另外一个我们关心的统计量就是方差。方差能够体现变量变化的程度。在我们的例子中,方差还可以告诉我们投资风险的大小。那些股价变动过于剧烈的股票一定会给持有者制造麻烦。
      NumPy中,计算方差只需要一行代码,看下面:
    print "variance =", np.var(c)
    

    将给出如下结果:

    variance = 50.126517888888884
    
    • (6) 既然我们不相信NumPy的函数,那就再次根据文档中方差的定义来复核一下结果。注意,这里方差的定义可能与你在统计学的书中看到的不一致,但这个定义在统计学上更为通用。方差是指各个数据与所有数据算术平均数的离差平方和除以数据个数所得到的值
      一些书里面告诉我们,应该用数据个数减1去除离差平方和1
    print("variance from definition =", np.mean((c - c.mean())**2))
    

    输出结果如下:

    variance from definition = 50.126517888888884
    
    • simplestats.py完整代码如下:
    import numpy as np
    
    c = np.loadtxt('data.csv', delimiter=',', usecols=(6,), unpack=True)
    
    print("median =", np.median(c))
    sorted_close = np.msort(c)
    print("sorted =", sorted_close)
    
    N = len(c)
    print("middle =", sorted_close[int((N - 1)/2)])
    print("average middle =", (sorted_close[int(N /2)] + sorted_close[int((N - 1) / 2)]) / 2)
    
    print("variance =", np.var(c))
    print("variance from definition =", np.mean((c - c.mean())**2))
    

    3.11 股票收益率

    在学术文献中,收盘价的分析常常是基于股票收益率和对数收益率的简单收益率是指相邻两个价格之间的变化率,而对数收益率是指所有价格取对数后两两之间的差值。我们在高中学习过对数的知识,“a”的对数减去“b”的对数就等于“a除以b”的对数。因此,对数收益率也可以用来衡量价格的变化率。注意,由于收益率是一个比值,例如我们用美元除以美元(也可以是其他货币单位),因此它是无量纲的。总之,投资者最感兴趣的是收益率的方差或标准差,因为这代表着投资风险的大小

    3.12 动手实践:分析股票收益率

    按照如下步骤分析股票收益率。

    • (1) 首先,我们来计算简单收益率。 NumPy中的diff函数可以返回一个由相邻数组元素的差值构成的数组。这有点类似于微积分中的微分。为了计算收益率,我们还需要用差值除以前一天的价格。不过这里要注意, diff返回的数组比收盘价数组少一个元素。经过仔细考虑,我们使用如下代码:
    returns = np.diff( c ) / c[ : -1]
    

    注意,我们没有用收盘价数组中的最后一个值做除数。接下来,std函数计算标准差

    print("Standard deviation =", np.std(returns))
    

    输出结果如下:

    Standard deviation = 0.012922134436826306
    
    • (2) 对数收益率计算起来甚至更简单一些。我们先用log函数得到每一个收盘价的对数,再对结果使用diff函数即可
    logreturns = np.diff( np.log(c) )
    

    一般情况下,我们应检查输入数组以确保其不含有零和负数。否则,将得到一个错误提示
    不过在我们的例子中,股价总为正值,所以可以将检查省略掉。

    • (3) 我们很可能对哪些交易日的收益率为正值非常感兴趣。在完成了前面的步骤之后,我们只需要用where函数就可以做到这一点。 where函数可以根据指定的条件返回所有满足条件的数组元素的索引值。输入如下代码:
    posretindices = np.where(returns > 0)
    print("Indices with positive returns", posretindices)
    

    即可输出该数组中所有正值元素的索引。

    Indices with positive returns (array([ 0,  1,  4,  5,  6,  7,  9, 10, 11, 12, 16, 17, 18, 19, 21, 22, 23,
           25, 28], dtype=int64),)
    
    • (4) 在投资学中,波动率(volatility)是对价格变动的一种度量。历史波动率可以根据历史价格数据计算得出。计算历史波动率(如年波动率或月波动率)时,需要用到对数收益率。**年波动率等于对数收益率的标准差除以其均值,再除以交易日倒数的平方根,通常交易日取252天。**我们用stdmean函数来计算,代码如下所示:
    annual_volatility = np.std(logreturns)/np.mean(logreturns)
    annual_volatility = annual_volatility / np.sqrt(1./252.)
    print("Yearly volatility",annual_volatility)
    

    年波动率输出为:

    Yearly volatility 129.27478991115132
    
    • (5) 请注意sqrt函数中的除法运算。在Python中,整数的除法和浮点数的除法运算机制不同,我们必须使用浮点数才能得到正确的结果。与计算年波动率的方法类似,计算月波动率如下:
    print("Monthly volatility", annual_volatility * np.sqrt(1./12.))
    

    月波动率输出为:

    Monthly volatility 37.318417377317765
    

    分析股票收益率示例完整代码return.py文件代码如下:

    import numpy as np
    
    c = np.loadtxt('data.csv', delimiter=',', usecols=(6,), unpack=True)
    
    returns = np.diff( c ) / c[ : -1]
    print("Standard deviation =", np.std(returns))
    
    logreturns = np.diff( np.log(c) )
    posretindices = np.where(returns > 0)
    print("Indices with positive returns", posretindices)
    
    annual_volatility = np.std(logreturns)/np.mean(logreturns)
    annual_volatility = annual_volatility / np.sqrt(1./252.)
    print("Yearly volatility", annual_volatility)
    print("Monthly volatility", annual_volatility * np.sqrt(1./12.))
    

    3.13 日期分析

    你是否有时候会有星期一焦虑症和星期五狂躁症?想知道股票市场是否受上述现象的影响?我认为这值得深入研究。

    3.14 动手实践:分析日期数据

    首先,我们要读入收盘价数据。随后,根据星期几来切分收盘价数据,并分别计算平均价格。

    最后,我们将找出一周中哪一天的平均收盘价最高,哪一天的最低。在我们动手之前,有一个善意的提醒:你可能希望利用分析结果在某一天买股票或卖股票,然而我们这里的数据量不足以做出可靠的决策,请先咨询专业的统计分析师再做决定!

    程序员不喜欢日期,因为处理日期总是很烦琐。 NumPy是面向浮点数运算的,因此需要对日期做一些专门的处理。请自行尝试如下代码,单独编写脚本文件或使用本书附带的代码文件:

    import numpy as np
    from datetime import datetime
    
    dates, close=np.loadtxt('data.csv', delimiter=',', usecols=(1,6), unpack=True)
    

    执行以上代码后会得到一个错误提示

    ValueError: invalid literal for float(): 28-01-2011
    

    按如下步骤处理日期

    • (1) 显然, NumPy尝试把日期转换成浮点数我们需要做的是显式地告诉NumPy怎样来转换日期,而这需要用到loadtxt函数中的一个特定的参数。这个参数就是converters,它是一本数据列和转换函数之间进行映射的字典。

    为此,我们必须写出转换函数:

    def datestr2num(s):
        return datetime.strptime(s.decode('ascii'), "%d-%m-%Y").date().weekday()
    

    我们将日期作为字符串传给datestr2num函数,如“28-01-2011”。这个字符串首先会按照指定的形式"%d-%m-%Y"转换成一个datetime对象。补充一点,这是由Python标准库提供的功能,与NumPy无关。随后, datetime对象被转换为date对象。最后,调用weekday方法返回一个数字。如同你在注释中看到的,这个数字可以是0到6的整数, 0代表星期一, 6代表星期天。当然,具体的数字并不重要,只是用作标识。

    注意:data.csv文件第二列数据为日期格式字符串,loadtxt()默认读取数据需要为二进制编码格式,而返回的值为字节字符串bytes,所以需要把它转化二进制格式的string,故需要对字符串解码,使用函数decode(‘asii’),变成string格式。否则,抛出TypeError: strptime() argument 1 must be str, not bytes异常。

    • (2) 接下来,我们将日期转换函数挂接上去,这样就可以读入数据了。
    dates, close=np.loadtxt('data.csv', delimiter=',', usecols=(1,6), converters={1: datestr2num}, unpack=True)
    print("Dates =", dates)
    

    输出结果如下:

    Dates = [4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 1. 2. 3. 4. 0. 1. 2. 3.
     4. 0. 1. 2. 3. 4.]
    

    如你所见,没有出现星期六和星期天。股票交易在周末是休市的。

    • (3) 我们来创建一个包含5个元素的数组,分别代表一周的5个工作日。数组元素将初始化为0。
    averages = np.zeros(5)
    

    这个数组将用于保存各工作日的平均收盘价。

    • (4) 我们已经知道, where函数会根据指定的条件返回所有满足条件的数组元素的索引值。
      **take函数可以按照这些索引值从数组中取出相应的元素。**我们将用take函数来获取各个工作日的收盘价。在下面的循环体中,我们将遍历0到4的日期标识,或者说是遍历星期一到星期五,然后用where函数得到各工作日的索引值并存储在indices数组中。在用take函数获取这些索引值相应的元素值。最后,我们对每个工作日计算出平均值存放在averages数组中。代码如下:
    averages = np.zeros(5)
    
    for i in range(5):
        indices = np.where(dates == i) 
        prices = np.take(close, indices)
        avg = np.mean(prices)
        print("Day", i, "prices", prices, "Average", avg)
        averages[i] = avg
    

    输出结果如下:

    Day 0 prices [[339.32 351.88 359.18 353.21 355.36]] Average 351.7900000000001
    Day 1 prices [[345.03 355.2  359.9  338.61 349.31 355.76]] Average 350.63500000000005
    Day 2 prices [[344.32 358.16 363.13 342.62 352.12 352.47]] Average 352.1366666666666
    Day 3 prices [[343.44 354.54 358.3  342.88 359.56 346.67]] Average 350.8983333333333
    Day 4 prices [[336.1  346.5  356.85 350.56 348.16 360.   351.99]] Average 350.0228571428571
    
    • (5) 如果你愿意,还可以找出哪个工作日的平均收盘价是最高的,哪个是最低的。这很容易做到,用maxmin函数即可,代码如下:
    top = np.max(averages)
    print( "Highest average", top)
    print( "Top day of the week", np.argmax(averages))
    
    bottom = np.min(averages)
    print( "Lowest average", bottom)
    print( "Bottom day of the week", np.argmin(averages))
    

    输出结果如下:

    Highest average 352.1366666666666
    Top day of the week 2
    Lowest average 350.0228571428571
    Bottom day of the week 4
    

    刚才做了些什么
    argmin函数返回的是averages数组中最小元素的索引值,这里是4,也就是星期五。而
    argmax函数返回的是averages数组中最大元素的索引值,这里是2,也就是星期三。

    示例代码完整代码如下:

    import numpy as np
    from datetime import datetime
    
    def datestr2num(s):
        return datetime.strptime(s.decode('ascii'), "%d-%m-%Y").date().weekday()
    
    dates, close=np.loadtxt('data.csv', delimiter=',', usecols=(1,6), converters={1: datestr2num}, unpack=True)
    print("Dates =", dates)
    
    averages = np.zeros(5)
    
    for i in range(5):
        indices = np.where(dates == i) 
        prices = np.take(close, indices)
        avg = np.mean(prices)
        print("Day", i, "prices", prices, "Average", avg)
        averages[i] = avg
        
    top = np.max(averages)
    print( "Highest average", top)
    print( "Top day of the week", np.argmax(averages))
    
    bottom = np.min(averages)
    print( "Lowest average", bottom)
    print( "Bottom day of the week", np.argmin(averages))
    

    3.15 周汇总

    在之前的“动手实践”教程中,我们用的是盘后数据。也就是说,这些数据是将一整天的交易数据汇总得到的。如果你对棉花市场感兴趣,并且有数十年的数据,你可能希望对数据做进一步的汇总和压缩。开始动手吧。我们来把苹果股票数据按周进行汇总。

    3.16 动手实践:汇总数据

    我们将要汇总整个交易周中从周一到周五的所有数据。数据覆盖的时间段内有一个节假日:2月21日是总统纪念日。这天是星期一,美国股市休市,因此在我们的示例数据中没有这一天的数据记录。数据中的第一天为星期五,处理起来不太方便。按照如下步骤来汇总数据。

    • (1) 为了简单起见,我们只考虑前三周的数据,这样就避免了节假日造成的数据缺失。你可以稍后尝试对其进行拓展。
    import numpy as np
    from datetime import datetime
    
    def datestr2num(s):
        return datetime.strptime(s.decode('ascii'), "%d-%m-%Y").date().weekday()
    
    dates, open, high, low, close=np.loadtxt('data.csv', delimiter=',', usecols=(1, 3, 4, 5, 6), converters={1: datestr2num}, unpack=True)
    
    close = close[:16]
    dates = dates[:16]
    
    • (2) 首先我们来找到示例数据中的第一个星期一。回忆一下,在Python中星期一对应的编码是0,这可以作为where函数的条件。接着,我们要取出数组中的首个元素,其索引值为0。where函数返回的结果是一个多维数组,因此要用ravel函数将其展平
    # 找到第一个星期一
    first_monday = np.ravel(np.where(dates == 0))[0]
    print( "The first Monday index is", first_monday)
    

    输出结果如下:

    The first Monday index is 1
    
    • (3) 下面要做的是找到示例数据的最后一个星期五,方法和找第一个星期一类似。星期五相对应的编码是4。此外,我们用-1作为索引值来定位数组的最后一个元素。
    # 找到最后一个星期五
    last_friday = np.ravel(np.where(dates == 4))[-1]
    print( "The last Friday index is", last_friday)
    

    输出结果如下:

    The last Friday index is 15
    

    接下来创建一个数组,用于存储三周内每一天的索引值。

    weeks_indices = np.arange(first_monday, last_friday + 1)
    print( "Weeks indices initial", weeks_indices)
    

    输出结果如下:

    Weeks indices initial [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
    
    • (4) 按照每个子数组5个元素,用split函数切分数组:
    weeks_indices = np.split(weeks_indices, 3)
    print( "Weeks indices after split", weeks_indices)
    

    输出结果如下:

    Weeks indices after split [array([1, 2, 3, 4, 5], dtype=int64), array([ 6,  7,  8,  9, 10], dtype=int64), array([11, 12, 13, 14, 15], dtype=int64)]
    
    • (5) 在NumPy中,数组的维度也被称作轴。现在我们来熟悉一下apply_along_axis函数。这个函数会调用另外一个由我们给出的函数,作用于每一个数组元素上。目前我们的数组中有3个元素,分别对应于示例数据中的3个星期,元素中的索引值对应于示例数据中的1天。在调用apply_along_axis时提供我们自定义的函数名summarize,并指定要作用的轴或维度的编号(如取1)、目标数组以及可变数量的summarize函数的参数。
    weeksummary = np.apply_along_axis(summarize, 1, weeks_indices, open, high, low, close)
    print( "Week summary", weeksummary)
    

    (6) 编写summarize函数。该函数将为每一周的数据返回一个元组,包含这一周的开盘价、最高价、最低价和收盘价,类似于每天的盘后数据。

    def summarize(a, o, h, l, c):
        monday_open = o[a[0]]
        week_high = np.max( np.take(h, a) )
        week_low = np.min( np.take(l, a) )
        friday_close = c[a[-1]]
    
        return("APPL", monday_open, week_high, week_low, friday_close)
    

    注意,我们用take函数来根据索引值获取数组元素的值,并用maxmin函数轻松计算出一周的最高股价和最低股价。一周的开盘价即为周一的开盘价,而一周的收盘价即为周五的收盘价。

    Week summary [['APPL' '335.8' '346.7' '334.3' '346.5']
     ['APPL' '347.89' '360.0' '347.64' '356.85']
     ['APPL' '356.79' '364.9' '349.52' '350.56']]
    

    (7) 使用NumPy中的savetxt函数,将数据保存至文件。

    np.savetxt("weeksummary.csv", weeksummary, delimiter=",", fmt="%s")
    

    如代码中所示,我们指定了文件名、需要保存的数组名、分隔符(在这个例子中为英文标点逗号)以及存储浮点数的格式。
    格式字符串以一个百分号开始。接下来是一个可选的标志字符: -表示结果左对齐, 0表示左端补0, +表示输出符号(正号+或负号-)。第三部分为可选的输出宽度参数,表示输出的最小位数。第四部分是精度格式符,以"."开头,后面跟一个表示精度的整数。最后是一个类型指定字符,在我们的例子中指定为字符串类型。

    weeksummary.csv文件内容如下:

    APPL,335.8,346.7,334.3,346.5
    APPL,347.89,360.0,347.64,356.85
    APPL,356.79,364.9,349.52,350.56
    

    示例代码完整代码如下:

    import numpy as np
    from datetime import datetime
    
    def datestr2num(s):
        return datetime.strptime(s.decode('ascii'), "%d-%m-%Y").date().weekday()
    
    dates, open, high, low, close=np.loadtxt('data.csv', delimiter=',', usecols=(1, 3, 4, 5, 6), converters={1: datestr2num}, unpack=True)
    
    close = close[:16]
    dates = dates[:16]
    
    # get first Monday
    first_monday = np.ravel(np.where(dates == 0))[0]
    print( "The first Monday index is", first_monday)
    
    # get last Friday
    last_friday = np.ravel(np.where(dates == 4))[-1]
    print( "The last Friday index is", last_friday)
    
    weeks_indices = np.arange(first_monday, last_friday + 1)
    print( "Weeks indices initial", weeks_indices)
    
    weeks_indices = np.split(weeks_indices, 3)
    print( "Weeks indices after split", weeks_indices)
    
    def summarize(a, o, h, l, c):
        monday_open = o[a[0]]
        week_high = np.max( np.take(h, a) )
        week_low = np.min( np.take(l, a) )
        friday_close = c[a[-1]]
    
        return("APPL", monday_open, week_high, week_low, friday_close)
    
    weeksummary = np.apply_along_axis(summarize, 1, weeks_indices, open, high, low, close)
    print( "Week summary", weeksummary)
    
    np.savetxt("weeksummary.csv", weeksummary, delimiter=",", fmt="%s")
    

    1. 注意样本方差和总体方差在计算上的区别。总体方差是用数据个数去除离差平方和,而样本方差则是用样本数据个数减1去除离差平方和,其中样本数据个数减1(即n-1)称为自由度。之所以有这样的差别,是为了保证样本方差是一个无偏估计量。——译者注 ↩︎

    展开全文
  • 张晓峒分位数回归讲义解析.doc

    千次阅读 2021-01-17 16:51:44
    以一元回归为例,如果用LAD估计的中位数回归回归yt的分布是非对称的。如果散点图上侧分位数回归直线之间与下侧分位数回归直线之间相比,相互比较接近,则说明被解释变量yt的分布是左偏倚的。反之是右偏倚的。对于...
  • 灰色预测MATLAB程序

    2021-04-18 09:53:23
    《灰色预测MATLAB程序》由会员分享,...其1次累 *加生成列为工(尹,呛).宗D(祸,其中I(jt)二 2 xf0) (f)= k 二 1=2=二临曲定义计的灰导数为工住)-工供-1)令尹为数列曲的邻值生成数列”即尹(切=加&)+(1-仅)盂住...
  • 文章目录问题Boston 数据集查看数据集数据描述构建分类模型数据可视化logistic 分类模型构建分类模型的因变量构建三个不同自变量的模型交叉验证结果分析LDA ...目的是预测一个区域的犯罪率是否高于所有犯罪率的中位数
  • 之前的某次面试,聊到了缺失值填充方法,经面试官指点学到了一些技能,下面简要总结一下。 常见的缺失值填充方法有填充默认值、均值、众数、KNN填充、以及把缺失值作为新的label通过模型来预测等方式,为了介绍这...
  • 标签:在体彩七位数玩法中,要想预测准各个位置上的数字非常难,但如果能全面考虑各种因数,并按一定的“程序”来选号,一定会提高中奖的机会。一、数字的选择1、选定出根据近10—20期出现数码的情况,确定本期最...
  • 在周易占卜尤其是梅花易占卜,如何在占卜吉凶祸福时,同时揭示更多的信息如数字、应期,对大多数梅花易初学者来说,都是一道难以逾越的门槛。今天我将以实战实测的例子,来对梅花易的取方法做一定的分析和...
  • Borda的计算.ppt

    2021-04-22 12:25:17
    Borda的计算*数学与计算机科学学院 模糊集理论及其应用 — 第六章 模糊集理论及其应用 第六章 模糊决策与模糊预测 /shujixueyuan 数学与计算机科学学院 /shujixueyuan 数学与计算机科学学院 6.3.1 评分 1....
  • 这里写自定义目录标题MATLAB...四分位法的理论如下图所示,参考刘芳《风电功率预测数据集的建立》的论文。 程序实现 p=xlsread('treated_data.xlsx','fp'); %% 对风电功率数据进行四分位法清洗 B=p; [a,b]=sort(B); ol
  • 实验二、语法设计——基于LL(1)文法的预测分析表一、实验目的通过实验教学,加深学生对所学的关于编译的理论知识的理解,增强学生对所学知识的综合应用能力,并通过实践达到对所学的知识进行验证。通过对基于LL(1)...
  • 时间序列预测的7种方法

    千次阅读 2021-09-05 11:30:58
    #取 #df=pd.read_csv('jetrail.csv') #print(df.head()) ''' ID Datetime Count 0 0 25-08-2012 00:00 8 1 1 25-08-2012 01:00 2 2 2 25-08-2012 02:00 6 3 3 25-08-2012 03:00 2 4 4 25-08-2012 04:0.
  • 本文详细地梳理及实现了深度学习模型构建及预测的全流程,代码示例基于python及神经网络库keras,通过设计一个深度神经网络模型做波士顿房价预测。主要依赖的Python库有:keras、...
  • 一、简介 1 概述 BP(Back Propagation)神经网络是1986年由Rumelhart和McCelland为首的科研小组提出,参见他们发表在Nature上的论文 Learning representations by ...它的学习规则是使用最速下降,通过反向传播来
  • 西北工业大学2021模校赛B题 - 波士顿房价的预测 文章目录西北工业大学2021模校赛B题 - 波士顿房价的预测一.文章声明:二.题目简述:三.使用python及其学习对于问题进行分析:3.1 数据基本样貌解析:3.2 数据...
  • 单纯选优决策:如果决策有遇到的是这样一类问题,其行为方案仅是有限个,而且掌握的数据资料也无须加工计算,就可以逐个比较直接选出最优方案和最优行动,这种在确定情况下的决策就是单纯2.动态经济预测: 是指...
  • 一、单选题 下列属于观察的缺点是( )。...A头脑风暴 B案头调研 C试验调研 D分层抽样 3、()是要求在一受控制的环境下,使其它因素保持不变,研究所控制的变量(因素、自变量)对某一变量或某些变量(因
  • 预测多关系和异构网络的链接 摘要 链接预测是网络分析的一项重要任务,它有益于各个领域的研究人员和组织。现实世界的许多网络,例如社交网络,是异构的,具有多种类型的链接和复杂的依赖结构。这种网络的...
  • 电力负荷预测三篇综述总结

    万次阅读 多人点赞 2021-01-30 21:28:08
    对前面三篇关于负荷预测的综述论文进行一个总结。
  • 1、精品自学考试资料推荐全国 2019 年 4 月高等教育自学考试计算机原理试题课程代码: 02384第一部分选择题(共 25 分)一、单项选择题(本大题共25 小题,每小题 1 分,共 25 分)在每小题列出的四个选项只有一个选项...
  • 曾在丁香园论坛里遇到过朋友求助,自己也尝试回答过,论坛里回答的言简意赅,针对问题论问题,没有详细的原理说明,今天趁回复朋友邮件的机会,就大致总结下自己对C-index的理解以及在R软件的计算过程。...
  • Nuclear开始为什么Nuclear 这里列举Nuclear在竞品的优势: 借助浏览器本身的机制,无任何代码约定和入侵 放心使用HTML+CSS+JS observejs替代EventLoop.requestAni ...串 &amp&semi; 容斥原理题意: 给出n (n&...
  • 先分析一下你写的程序吧。function y=sma(x,n) 输入为数组x,和数组的长度length(n)for i=3:n;... 你定义的sum就是一个,而不是数组for t=3:3-N+1t=t-1; 这步你会让循环变量在加一后减一成为死循环。sum=sum+x(...
  • 史丰收速算的革命性贡献是:从高位算起,预测进位。不需要九九表,彻底颠覆了传统手算! 速算的核心基础是:1位数乘以多位数的乘法。 其中,乘以7是最复杂的,就以它为例。 因为,1/7 是个循环小数:0.142857......
  • 《市场调研与预测》自考试题(二)单项选择题(10分,1分/题)1. 实验通过实验对比,可以比较清楚地分析事物的(??????)。A. 变化规律?????????? 同的思路?自己先思考,如果需要可以把你的不同的想法记录下来,等会B. ...
  • 性能 - 我应该使用乘法还是除?这是一个愚蠢有趣的问题:让我们说我们必须执行一个简单的操作,我们需要一半的变量值。 通常有两种方法:y = x / 2.0;// or...y = x * 0.5;假设我们正在使用该语言提供的标准运算符...
  • 同时我也计划了一个彩票数据框架的搭建,分析和预测的框架,会在今年逐步发表,拟定了一个目录,大家有什么样的意见和和问题,可以看看,留言我会在后面的文章逐步改善:彩票数据框架与分析预测总目录。...
  • 绝大多数大脑成像研究依靠对不同大脑的空间配准过程的形变程度来解释大体解剖学被试之间的差异。其次,被试可能使用不同的策略或认知加工,涉及不同的大脑环路。心理学家在设计他们的任务时非常小心,以限制这种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,045
精华内容 16,018
关键字:

中位数预测法