Python matplotlib.pyplot 模块,hlines() 实例源码

我们从Python开源项目中,提取了以下20个代码示例,用于说明如何使用matplotlib.pyplot.hlines()

项目:voxcelchain    作者:hiroaki-kaneda    | 项目源码 | 文件源码
def create_graph():
    logfile = 'result/log'
    xs = []
    ys = []
    ls = []
    f = open(logfile, 'r')
    data = json.load(f)

    print(data)

    for d in data:
        xs.append(d["iteration"])
        ys.append(d["main/accuracy"])
        ls.append(d["main/loss"])

    plt.clf()
    plt.cla()
    plt.hlines(1, 0, np.max(xs), colors='r', linestyles="dashed")  # y=-1, 1??????
    plt.title(r"loss/accuracy")
    plt.plot(xs, ys, label="accuracy")
    plt.plot(xs, ls, label="loss")
    plt.legend()
    plt.savefig("result/log.png")
项目:coquery    作者:gkunter    | 项目源码 | 文件源码
def lineplot(x=None, y=None, data=None, order=None, palette=None,
             linewidth=0, ax=None, orient="v", **kwargs):
    if ax is None:
        ax = plt.gca()
    if not order:
        order = y.unique()
    order = list(sorted(order))
    func = plt.vlines if orient=="v" else plt.hlines
    for i, lev in enumerate(order):
        func(x[y == lev], i + 0.025, i + 0.975, colors=palette[i], linewidth=1)

    if len(order) < 2:
        ax.set(yticks=[])
    else:
        ax.set(yticks=[0.5 + n for n in range(len(order))])
        ax.set(yticklabels=order)
    ax.set(xlim=(0, max(x)))
    ax.set(ylim=(len(order), 0))
    return ax
项目:House-Pricing    作者:playing-kaggle    | 项目源码 | 文件源码
def linear_regression():
    lr = LinearRegression()
    lr.fit(X_train, y_train)
    # Look at predictions on training and validation set
    print("RMSE on Training set :", rmse_cv(lr, train_split, y).mean())
    y_train_pred = lr.predict(train_split)
    print('rmsle calculate by self:', rmsle(list(np.exp(y) - 1), list(np.exp(y_train_pred) - 1)))
    plt.scatter(y_train_pred, y_train_pred - y, c="blue", marker="s", label="Training data")
    plt.title("Linear regression")
    plt.xlabel("Predicted values")
    plt.ylabel("Residuals")
    plt.legend(loc="upper left")
    plt.hlines(y=0, xmin=10.5, xmax=13.5, color="red")
    plt.show()
    # Plot predictions
    plt.scatter(y_train_pred, y, c="blue", marker="s", label="Training data")
    plt.title("Linear regression")
    plt.xlabel("Predicted values")
    plt.ylabel("Real values")
    plt.legend(loc="upper left")
    plt.plot([10.5, 13.5], [10.5, 13.5], c="red")
    plt.show()
    return lr
项目:House-Pricing    作者:playing-kaggle    | 项目源码 | 文件源码
def GDBT_regression(X=train_df_munged,Y=label_df['SalePrice']):
    est = GradientBoostingRegressor(n_estimators=50,max_depth=3,learning_rate=0.1)
    X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.3,random_state=0)
    est.fit(X_train,Y_train)
    y_train_pred = est.predict(X_test)
    plt.scatter(y_train_pred,y_train_pred - Y_test,c = 'blue',marker='s', label='error on training data')

    plt.title("Linear regression with  GDBT")
    plt.xlabel("Predicted values")
    plt.ylabel("Residuals")
    plt.legend(loc="upper left")
    plt.hlines(y=0, xmin=10.5, xmax=13.5, color="red")
    plt.show()
    # Plot predictions
    plt.scatter(Y_test, y_train_pred, c="blue", marker="s", label="Training data")

    plt.title("Linear regression with  GDBT")
    plt.xlabel("Predicted values")
    plt.ylabel("Real values")
    plt.legend(loc="upper left")
    plt.plot([10.5, 13.5], [10.5, 13.5], c="red")
    plt.show()
    print('rmse value:',rmse(Y_test,y_train_pred))

    return est
项目:Parallel-SGD    作者:angadgill    | 项目源码 | 文件源码
def plot_samples(S, axis_list=None):
    plt.scatter(S[:, 0], S[:, 1], s=2, marker='o', zorder=10,
                color='steelblue', alpha=0.5)
    if axis_list is not None:
        colors = ['orange', 'red']
        for color, axis in zip(colors, axis_list):
            axis /= axis.std()
            x_axis, y_axis = axis
            # Trick to get legend to work
            plt.plot(0.1 * x_axis, 0.1 * y_axis, linewidth=2, color=color)
            plt.quiver(0, 0, x_axis, y_axis, zorder=11, width=0.01, scale=6,
                       color=color)

    plt.hlines(0, -3, 3)
    plt.vlines(0, -3, 3)
    plt.xlim(-3, 3)
    plt.ylim(-3, 3)
    plt.xlabel('x')
    plt.ylabel('y')
项目:OpenTDA    作者:outlace    | 项目源码 | 文件源码
def graph_barcode(data, ph, homology_group=0):
    persistence = ph.transform(data)
    # this function just produces the barcode graph for each homology group
    xstart = [s[1][0] for s in persistence if s[0] == homology_group]
    xstop = [s[1][1] for s in persistence if s[0] == homology_group]
    y = [0.1 * x + 0.1 for x in range(len(xstart))]
    plt.hlines(y, xstart, xstop, color='b', lw=4)
    # Setup the plot
    ax = plt.gca()
    plt.ylim(0, max(y) + 0.1)
    ax.yaxis.set_major_formatter(plt.NullFormatter())
    plt.xlabel('epsilon')
    plt.ylabel("Betti dim %s" % (homology_group,))
    plt.show()
项目:tensorpac    作者:EtienneCmb    | 项目源码 | 文件源码
def plot(nb, pvec, avec, title):
    """Plotting function."""
    pvecm = pvec.mean(1)
    avecm = avec.mean(1)
    plt.subplot(1, 4, nb)
    plt.vlines(pvecm, -10, 500, color='#ab4642')
    plt.hlines(avecm, -10, 500, color='slateblue')
    plt.xlabel('Frequency for phase (hz')
    plt.ylabel('Frequency for amplitude.mean(1)')
    plt.title(title)
    plt.xlim([0, 30])
    plt.ylim([60, 200])
项目:future_data_analyse    作者:ipqhjjybj    | 项目源码 | 文件源码
def plotFigure(self):
        print "plotFigure"

        xx = []
        yy = []
        for (x,y) in self.cp_data:
            xx.append(x)
            yy.append(y+1000)
        plt.scatter(xx , yy) 
        xx = []
        yy = []
        for (x , y) in self.ori_data:
            xx.append(x)
            yy.append(y-1000)
        #print y
        plt.plot(xx , yy) 
        #print self.KLinePointArr

        x1 = [x[0] for x in self.KLinePointArr if x[3] == HeiMoShui]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == HeiMoShui]

        plt.scatter(x1, y1 , c = HeiMoShui , marker = 's')


        x1 = [x[0] for x in self.KLinePointArr if x[3] == HongMoShui]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == HongMoShui]
        plt.scatter(x1, y1 , c = HongMoShui , marker = 's')

        x1 = [x[0] for x in self.KLinePointArr if x[3] == QianBi]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == QianBi]
        plt.scatter(x1, y1 , c = QianBi , marker = 'x')

        #print self.keyPointArr
        for (xx,yy,ccolor) in self.keyPointArr:
            x = [xx - datetime.timedelta(days=20) , xx + datetime.timedelta(days=20)]
            y = [yy,yy]
            #plt.plot(x , y, color = ccolor) 
            plt.hlines( y[0], x[0], x[1] , colors = ccolor , linestyles = "dashed")

        plt.show()
项目:tschdata    作者:tum-lkn    | 项目源码 | 文件源码
def plot_all_reliabilities():
    """
    Plot packet delivery ratio for all data sets
    :return:
    """
    rel = []
    avg = []

    for filename in get_all_files(gl_dump_path):
        p = BasicProcessor(filename=filename)

        # compensate for the rest
        p.correct_timeline(clean_all=False)

        # plot the timeline
        # p.plot_timeline(writer=None)
        r, w = p.plot_motes_reliability(return_result=True)
        rel.append(r)
        avg.append(w)

    plt.figure(figsize=(7.5, 3.5))
    bp = plt.boxplot(rel, flierprops={'linewidth':1.5}, showmeans=True)

    plt.hlines(0.95, xmin=0, xmax=9, linestyles='--', linewidth=1, label='0.95')
    x_axis = list(range(9))
    labels = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII']

    plt.xticks(x_axis, labels)
    plt.grid(True)
    plt.ylim((0.35, 1.1))
    plt.legend(loc=4)

    plt.ylabel('PDR')

    set_box_plot(bp)

    plt.show()
项目:tschdata    作者:tum-lkn    | 项目源码 | 文件源码
def plot_delay_cdf():

    plt.figure(figsize=(7.5, 3.5))

    steps = [0.5, 1, 2, 5, 10]


    for idx, logfile in enumerate(get_all_files('../../data/raw/')):

        bp = BasicProcessor(filename=logfile)
        # delay_df.set_value(idx, 'set', logfile)
        delay_ser = pd.Series(bp.get_all_delays())

        # print(delay_ser)

        counts = []

        for step in steps:
            count = (delay_ser < step).sum() / len(delay_ser)
            counts.append(count)

        plt.plot([i+1 for i, _ in enumerate(steps)], counts, gl_line_color_map[idx], label=gl_legend_map[idx])

    plt.hlines(0.95, xmin=0, xmax=len(steps)+1, linestyles='--', linewidth=2, label='0.95')

    x_axis = [0.5] + list(range(1, len(steps)+1)) + [len(steps)+0.5]
    labels = [''] + [str(step) for step in steps] + ['']
    plt.xticks(x_axis, labels)
    plt.ylim(0.4, 1.1)
    plt.legend(loc=0, ncol=3)
    plt.grid(True)

    plt.xlabel('Deadline, s')
    plt.ylabel('Packet ratio')

    plt.show()
项目:House-Pricing    作者:playing-kaggle    | 项目源码 | 文件源码
def GDBT_regression(X=train_split,Y=y):
    est = GradientBoostingRegressor(n_estimators=75,max_depth=3,learning_rate=0.1)
    X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.3,random_state=0)
    est.fit(X_train,Y_train)
    y_train_pred = est.predict(X_test)
    plt.scatter(y_train_pred,y_train_pred - Y_test,c = 'blue',marker='s', label='error on training data')

    plt.title("Linear regression with  GDBT")
    plt.xlabel("Predicted values")
    plt.ylabel("Residuals")
    plt.legend(loc="upper left")
    plt.hlines(y=0, xmin=10.5, xmax=13.5, color="red")
    plt.show()
    # Plot predictions
    plt.scatter(Y_test, y_train_pred, c="blue", marker="s", label="Training data")

    plt.title("Linear regression with  GDBT")
    plt.xlabel("Predicted values")
    plt.ylabel("Real values")
    plt.legend(loc="upper left")
    plt.plot([10.5, 13.5], [10.5, 13.5], c="red")
    plt.show()
    print('rmse value:',rmsle(Y_test,y_train_pred))

    return est


# linear_regression()
# ridge_regression()
# Lasso_regression()
#model = Elasticnet_regression()
# '''
#         predict final result
#  '''
#
#
# coefs,lasso = Lasso_regression()
# selected_features = coefs[coefs['value'] != 0].index.values
# train_new = train_split[selected_features]
项目:python-machine-learning-book    作者:jeremyn    | 项目源码 | 文件源码
def evaluate_sklearn_linear_regression(X_train, X_test, y_train, y_test):
    lr = LinearRegression()
    lr.fit(X_train, y_train)
    y_train_pred = lr.predict(X_train)
    y_test_pred = lr.predict(X_test)

    plt.scatter(
        y_train_pred,
        y_train_pred - y_train,
        c='blue',
        marker='o',
        label='Training data',
    )
    plt.scatter(
        y_test_pred,
        y_test_pred - y_test,
        c='lightgreen',
        marker='s',
        label='Test data',
    )
    plt.xlabel('Predicted values')
    plt.ylabel('Residuals')
    plt.legend(loc='upper left')
    plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color='red')
    plt.xlim([-10, 50])

    plt.show()

    print("MSE train: %.3f, test: %.3f" % (
        mean_squared_error(y_train, y_train_pred),
        mean_squared_error(y_test, y_test_pred),
    ))
    print("R^2 train: %.3f, test: %.3f" % (
        r2_score(y_train, y_train_pred),
        r2_score(y_test, y_test_pred),
    ))
项目:ThinkX    作者:AllenDowney    | 项目源码 | 文件源码
def Hlines(ys, x1, x2, **options):
    """Plots a set of horizontal lines.

    Args:
      ys: sequence of y values
      x1: sequence of x values
      x2: sequence of x values
      options: keyword args passed to plt.vlines
    """
    options = _UnderrideColor(options)
    options = _Underride(options, linewidth=1, alpha=0.5)
    plt.hlines(ys, x1, x2, **options)
项目:Buffe    作者:bentzinir    | 项目源码 | 文件源码
def _print_junction(self):
        bw = self.game_params['board_width']
        lw = self.game_params['lane_width']

        # road marks
        plt.vlines(lw, -bw, -lw)
        plt.vlines(-lw, -bw, -lw)
        plt.vlines(-lw, lw, bw)
        plt.vlines(lw, lw, bw)
        plt.hlines(-lw, -bw, -lw)
        plt.hlines(-lw, lw, bw)
        plt.hlines(lw, -bw, -lw)
        plt.hlines(lw, lw, bw)

        # lane marks
        plt.vlines(0, -bw, -lw, linestyles='dashed')
        plt.vlines(0, lw, bw, linestyles='dashed')
        plt.hlines(0, -bw, -lw, linestyles='dashed')
        plt.hlines(0, lw, bw, linestyles='dashed')

        # stopping lines
        plt.hlines(-lw, 0, lw, linestyles='solid')
        plt.hlines(-lw-0.01, 0, lw, linestyles='solid')

        plt.hlines(lw, -lw, 0, linestyles='solid')
        plt.hlines(lw+0.01, -lw, 0, linestyles='solid')

        plt.vlines(-lw, -lw, 0, linestyles='solid')
        plt.vlines(-lw-0.01, -lw, 0, linestyles='solid')

        plt.vlines(lw, 0, lw, linestyles='solid')
        plt.vlines(lw+0.01, 0, lw, linestyles='solid')

        # print rails
        # self.ax.add_patch(Circle(xy=(lw,-lw), radius=lw/2, edgecolor='k', facecolor='none'))
        # self.ax.add_patch(Circle(xy=(-lw,-lw), radius=3*lw/2, edgecolor='k', facecolor='none'))
项目:future_data_analyse    作者:ipqhjjybj    | 项目源码 | 文件源码
def plotFigure(self):
        print "plotFigure"
        xx = []
        yy = []
        for (x,y) in self.cp_data:
            xx.append(x)
            yy.append(y+150)
        plt.scatter(xx , yy) 
        xx = []
        yy = []
        for (x , y , vol) in self.ori_data:
            xx.append(x)
            yy.append(y-150)
        #print y
        plt.plot(xx , yy) 
        #print self.KLinePointArr

        x1 = [x[0] for x in self.KLinePointArr if x[3] == HeiMoShui]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == HeiMoShui]

        plt.scatter(x1, y1 , c = HeiMoShui , marker = 's')


        x1 = [x[0] for x in self.KLinePointArr if x[3] == HongMoShui]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == HongMoShui]
        plt.scatter(x1, y1 , c = HongMoShui , marker = 's')

        x1 = [x[0] for x in self.KLinePointArr if x[3] == QianBi]
        y1 = [x[1] for x in self.KLinePointArr if x[3] == QianBi]
        plt.scatter(x1, y1 , c = QianBi , marker = 'x')

        #print self.keyPointArr
        for (xx,yy,ccolor) in self.keyPointArr:
            x = [xx - datetime.timedelta(days=5) , xx + datetime.timedelta(days=5)]
            y = [yy,yy]
            #plt.plot(x , y, color = ccolor) 
            plt.hlines( y[0], x[0], x[1] , colors = ccolor , linestyles = "dashed")
        #### ????
        #xx = [x[0] for x in self.keyPointArr]
        xx = [x[0] for x in self.ori_data ]
        x_vol = [x[0] for x in self.ori_data if x[0] in xx]
        y_vol = [x[2] / 10000.0 for x in self.ori_data if x[0] in x_vol]
        plt.bar(x_vol , y_vol)

        plt.show()
项目:House-Pricing    作者:playing-kaggle    | 项目源码 | 文件源码
def ridge_regression():
    ridge = RidgeCV(alphas=[0.01, 0.03, 0.06, 0.1, 0.3, 0.6, 1, 3, 6, 10, 30, 60])
    ridge.fit(X_train, y_train)
    alpha = ridge.alpha_
    print("Best alpha :", alpha)
    print("Try again for more precision with alphas centered around " + str(alpha))
    ridge = RidgeCV(alphas=[alpha * .6, alpha * .65, alpha * .7, alpha * .75, alpha * .8, alpha * .85,
                            alpha * .9, alpha * .95, alpha, alpha * 1.05, alpha * 1.1, alpha * 1.15,
                            alpha * 1.25, alpha * 1.3, alpha * 1.35, alpha * 1.4],
                    cv=10)
    ridge.fit(X_train, y_train)
    alpha = ridge.alpha_
    print("Best alpha :", alpha)
    print("Ridge RMSE on Training set :", rmse_cv(ridge, X_train, y_train).mean())
    print("Ridge RMSE on Test set :", rmse_cv(ridge, X_test, y_test).mean())
    y_train_rdg = ridge.predict(X_train)
    y_test_rdg = ridge.predict(X_test)
    # Plot residuals
    plt.scatter(y_train_rdg, y_train_rdg - y_train, c="blue", marker="s", label="Training data")
    plt.scatter(y_test_rdg, y_test_rdg - y_test, c="lightgreen", marker="s", label="Validation data")
    plt.title("Linear regression with Ridge regularization")
    plt.xlabel("Predicted values")
    plt.ylabel("Residuals")
    plt.legend(loc="upper left")
    plt.hlines(y=0, xmin=10.5, xmax=13.5, color="red")
    plt.show()
    # Plot predictions
    plt.scatter(y_train_rdg, y_train, c="blue", marker="s", label="Training data")
    plt.scatter(y_test_rdg, y_test, c="lightgreen", marker="s", label="Validation data")
    plt.title("Linear regression with Ridge regularization")
    plt.xlabel("Predicted values")
    plt.ylabel("Real values")
    plt.legend(loc="upper left")
    plt.plot([10.5, 13.5], [10.5, 13.5], c="red")
    plt.show()
    # Plot important coefficients
    coefs = pd.Series(ridge.coef_, index=X_train.columns)
    print("Ridge picked " + str(sum(coefs != 0)) + " features and eliminated the other " + \
          str(sum(coefs == 0)) + " features")
    imp_coefs = pd.concat([coefs.sort_values().head(10),
                           coefs.sort_values().tail(10)])
    imp_coefs.plot(kind="barh")
    plt.title("Coefficients in the Ridge Model")
    plt.show()

    return ridge
项目:House-Pricing    作者:playing-kaggle    | 项目源码 | 文件源码
def Lasso_regression():
    lasso = LassoCV(alphas=[0.0001, 0.0003, 0.0006, 0.001, 0.003, 0.006, 0.01, 0.03, 0.06, 0.1,
                            0.3, 0.6, 1],
                    max_iter=50000, cv=10)
    lasso.fit(train_split, y)
    alpha = lasso.alpha_
    print("Best alpha :", alpha)
    print("Try again for more precision with alphas centered around " + str(alpha))
    lasso = LassoCV(alphas=[alpha * .6, alpha * .65, alpha * .7, alpha * .75, alpha * .8,
                            alpha * .85, alpha * .9, alpha * .95, alpha, alpha * 1.05,
                            alpha * 1.1, alpha * 1.15, alpha * 1.25, alpha * 1.3, alpha * 1.35,
                            alpha * 1.4],
                    max_iter=50000, cv=10)
    lasso.fit(train_split, y)
    alpha = lasso.alpha_
    print("Best alpha :", alpha)
    print("Lasso RMSE on Training set :", rmse_cv(lasso, train_split, y).mean())

    y_train_las = lasso.predict(train_split)
    # Plot residuals
    plt.scatter(y_train_las, y_train_las - y, c="blue", marker="s", label="Training data")
    plt.title("Linear regression with Lasso regularization")
    plt.xlabel("Predicted values")
    plt.ylabel("Residuals")
    plt.legend(loc="upper left")
    plt.hlines(y=0, xmin=10.5, xmax=13.5, color="red")
    plt.show()
    # Plot predictions
    plt.scatter(y_train_las, y, c="blue", marker="s", label="Training data")
    plt.title("Linear regression with Lasso regularization")
    plt.xlabel("Predicted values")
    plt.ylabel("Real values")
    plt.legend(loc="upper left")
    plt.plot([10.5, 13.5], [10.5, 13.5], c="red")
    plt.show()
    # # Plot important coefficients
    coefs = pd.DataFrame(lasso.coef_, index=X_train.columns,columns=['value'])
    # print("Lasso picked " + str(sum(coefs != 0)) + " features and eliminated the other " + \
    #       str(sum(coefs == 0)) + " features")
    # imp_coefs = pd.concat([coefs.sort_values().head(10),
    #                        coefs.sort_values().tail(10)])
    # imp_coefs.plot(kind="barh")
    # plt.title("Coefficients in the Lasso Model")
    # plt.show()

    return coefs,lasso
项目:aiida-vasp    作者:DropD    | 项目源码 | 文件源码
def plot_bstr(bands_node,
              kpoints_node=None,
              title=None,
              efermi=None,
              use_parent_calc=False,
              **kwargs):
    '''
    py:function:: plot_bstr(bands_node[, kpoints_node=None])

    Use matplotlib to plot the bands stored in a BandsData node.
    A KpointsData node can optionally be given as a fallback for
    kpoint labels. The caller is responsible for giving a node
    with matching labels (as in they are in/out nodes of the same
    calculation).

    :param BandsData bands_node:
        The BandsData node will be searched labels first
    :param KpointsData kpoints_node:
        The optional KpointsData node will be searched only if no labels are
        present on the BandsData node. No consistency checks are performed.
    :return: the matplotlib figure containing the plot
    '''

    fig = plt.figure()
    title = title or 'Band Structure (pk=%s)' % bands_node.pk
    bands = bands_node.get_bands()
    _, nkp, _ = get_bs_dims(bands)
    plot_bands(bands_node, **kwargs)

    parent_calc = None
    if use_parent_calc:
        inputs = bands_node.get_inputs()
        parent_calc = inputs[0] if inputs else None

    efermi = get_efermi(parent_calc)
    kpoints_node = get_kp_node(parent_calc)

    if efermi:
        plt.hlines(efermi, plt.xlim()[0], nkp - 1, linestyles='dashed')
        plt.yticks(
            list(plt.yticks()[0]) + [efermi],
            [str(l) for l in plt.yticks()[0]] + [r'$E_{fermi}$'])

    try:
        kpx, kpl = get_kp_labels(bands_node, kpoints_node)
        plt.xticks(kpx, kpl)
        plt.vlines(kpx, plt.ylim()[0], plt.ylim()[1])
    except Exception:  # pylint: disable=broad-except
        pass

    plt.ylabel('Dispersion')
    plt.suptitle(title)
    return fig
项目:python-machine-learning-book    作者:jeremyn    | 项目源码 | 文件源码
def evaluate_random_forest_regression(X_train, X_test, y_train, y_test):
    forest = RandomForestRegressor(
        n_estimators=1000,
        criterion='mse',
        random_state=1,
    )
    forest.fit(X_train, y_train)
    y_train_pred = forest.predict(X_train)
    y_test_pred = forest.predict(X_test)

    print("MSE train: %.3f, test: %.3f" % (
        mean_squared_error(y_train, y_train_pred),
        mean_squared_error(y_test, y_test_pred),
    ))
    print("R^2 train: %.3f, test: %.3f" % (
        r2_score(y_train, y_train_pred),
        r2_score(y_test, y_test_pred),
    ))

    plt.scatter(
        y_train_pred,
        y_train_pred - y_train,
        c='black',
        marker='o',
        s=35,
        alpha=0.5,
        label='Training data',
    )
    plt.scatter(
        y_test_pred,
        y_test_pred - y_test,
        c='lightgreen',
        marker='s',
        s=35,
        alpha=0.7,
        label='Test data',
    )

    plt.xlabel('Predicted values')
    plt.ylabel('Residuals')
    plt.legend(loc='upper left')
    plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color='red')
    plt.xlim([-10, 50])

    plt.show()
项目:WellApplication    作者:inkenbrandt    | 项目源码 | 文件源码
def ganttPlotter(self):
        """Plots gantt plot using dictionary of stations and associated start and end dates;
        uses output from markGaps function"""

        labs, tickloc, col = [], [], []

        dateranges = self.dateranges
        stations = self.stations
        labels = self.labels

        # create color iterator for multi-color lines in gantt chart
        color = iter(plt.cm.Dark2(np.linspace(0, 1, len(stations))))

        plt.figure(figsize=[8, 10])
        fig, ax = plt.subplots()

        for i in range(len(stations)):
            c = next(color)
            for j in range(len(dateranges[stations[i]]) - 1):
                if (j + 1) % 2 != 0:
                    if len(labels) == 0 or len(labels) != len(stations):
                        plt.hlines(i + 1, dateranges[stations[i]][j], dateranges[stations[i]][j + 1], label=stations[i],
                                   color=c, linewidth=3)
                    else:
                        plt.hlines(i + 1, dateranges[stations[i]][j], dateranges[stations[i]][j + 1], label=labels[i],
                                   color=c, linewidth=3)
            labs.append(stations[i])
            tickloc.append(i + 1)
            col.append(c)
        plt.ylim(0, len(stations) + 1)

        if len(labels) == 0 or len(labels) != len(stations):
            labels = stations
            plt.yticks(tickloc, labs)
        else:
            plt.yticks(tickloc, labels)

        plt.xlabel('Date')
        plt.ylabel('Station Name')
        plt.grid(linewidth=0.2)

        gytl = plt.gca().get_yticklabels()
        for i in range(len(gytl)):
            gytl[i].set_color(col[i])
        plt.tight_layout()
        return fig