Exemple #1
0
def main(rms_data):
    global model
    RUL_preds = []

    total_data = rms_data[0].flatten()     # (858, 1)

    fig = plt.figure(figsize=(19, 9))

    "Moving Average"
    MA_data= np.convolve(total_data, np.ones((mv_size,)) / mv_size, mode='valid')[:610]   # (818, 1)
    RUL_true = [(num, rms) for num, rms in enumerate(MA_data) if thld_failure <= rms][0][0] # (818, 1)

    if type_ == 'linear':
        model = LinearRegression()
    elif type_ == 'exponential':
        model = Nonlinear_Regression()
    elif type_ == 'log':
        model = Nonlinear_Regression()
    elif type_ == 'Lloyd-Lipow':
        model = Nonlinear_Regression()
    elif type_ == 'gompertz':
        model = Nonlinear_Regression()
    elif type_ == 'power':
        model = Nonlinear_Regression()
    else:
        assert print('Unsupported regression model', file=sys.stderr)

    for cnt, tc in sorted(enumerate(tc_range)):
        ax1 = fig.add_subplot(4, 5, (1, 18))
        ax2 = fig.add_subplot(4, 5, (14, 20))

        observed_data = MA_data[:tc]

        time_curr_range = current_time(tc, n_window)
        time_pred_range = prediction_time(tc, n_window, range_pred)

        ax1.set_title('RUL prediction - {} regression |  time range: {}m ~ {}m'.format(type_, tc - n_window, tc))
        ax1.plot(MA_data, '.', label='total data')
        ax1.plot(observed_data, '.', label='observed_data')

        ax1.text(0, thld_safe + 0.05, str(thld_safe), color='c', fontsize=13, weight='bold')
        ax1.text(0, thld_fault + 0.05, str(thld_fault), color='r', fontsize=13, weight='bold')
        ax1.text(0, thld_failure + 0.05, str(thld_failure), color='r', fontsize=13, weight='bold')

        ax1.axvline(x=tc - n_window)
        ax1.axvline(x=tc)
        ax1.axhline(y=thld_safe, color='c', linestyle='-', label='Threshold safe')
        ax1.axhline(y=thld_fault, color='r', linestyle='--', label='Threshold fault')
        ax1.axhline(y=thld_failure, color='r', linestyle='-', label='Threshold failure')

        ax1.axvspan(tc - n_window, tc, facecolor='gray', alpha=0.5)

        ax1.set_xlabel('Times (m)')
        ax1.set_ylabel('RMS')
        ax1.set_xlim([-10, 900])
        ax1.set_ylim([min(observed_data) - 0.2, 10])
        ax1.annotate('True RUL: {}'.format(RUL_true), xy=(tc, 5), fontsize=12, weight='bold')

        if np.prod(observed_data[time_curr_range] >= thld_fault):
            if type_ == 'linear':
                model.fit(time_curr_range[:,np.newaxis], observed_data[time_curr_range])
                y_pred = model.predict(time_pred_range[:,np.newaxis])
                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc-n_window,tc+range_pred), y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red', weight='bold')

            elif type_ == 'exponential':
                popt, _ = model.fit_exp(time_curr_range, observed_data[time_curr_range])
                y_pred = model.exponential_func(prediction_time(tc, n_window, range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc-n_window,tc+range_pred)[:len(y_pred)], y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red', weight='bold')

            elif type_ == 'log':
                popt, _ = model.fit_log(time_curr_range, observed_data[time_curr_range])
                y_pred = model.log_func(prediction_time(tc, n_window, range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc-n_window, tc+range_pred), y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red', weight='bold')
            elif type_ == 'Lloyd-Lipow':
                popt, _ = model.fit_lipow(time_curr_range, observed_data[time_curr_range])
                y_pred = model.lipow_func(prediction_time(tc, n_window, range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc - n_window, tc + range_pred), y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red',
                             weight='bold')

            elif type_ == 'gompertz':
                popt, _ = model.fit_gom(time_curr_range, observed_data[time_curr_range])
                y_pred = model.gom_func(prediction_time(tc, n_window, range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc - n_window, tc + range_pred), y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red',
                             weight='bold')

            elif type_ == 'power':
                popt, _ = model.fit_pow(time_curr_range, observed_data[time_curr_range])
                y_pred = model.pow_func(prediction_time(tc, n_window, range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > thld_failure)[0][0] + (tc - n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred), file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred), file=sys.stderr)

                ax1.plot(np.arange(tc - n_window, tc + range_pred), y_pred, 'g-', linewidth=3)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred), xy=(tc, 4.8), fontsize=12, color='red',
                             weight='bold')
        else:
            RUL_preds += [590 + tc_range[cnt]]

        ax2.set_title('RUL curve')
        ax2.set_xlabel('Times (m)')
        ax2.set_ylabel('RUL')
        ax2.set_xlim([-10, RUL_true+20])
        ax2.set_ylim([-10, RUL_true+20])
        ax2.plot([0, RUL_true], [RUL_true, 0], label='True RUL curve')
        ax2.plot(tc_range[:len(RUL_preds)], np.array(RUL_preds) - tc_range[:len(RUL_preds)], label='predicted RUL curve')

        ax1.legend(loc='upper left', bbox_to_anchor=(0.01, 0.6))
        ax2.legend(loc='upper left', bbox_to_anchor=(0.01, 0.6))

        plt.tight_layout()
        # "Screen capture at specific time "
        # if tc == 605:
        #     plt.savefig('D:\\Onepredict_MK\\01 Solution 3 Team documents\\02 RUL Modeler\\관련 자료\\Regression capture image\\{} regression_{}time'.format(type_, tc))
        #     print('Capture done!')
        plt.pause(speed_search)
        plt.clf()
    os.system('pause')
def main(rms_data):
    global model

    RUL_preds = []
    total_data = rms_data[0].flatten()  # (858, 1)

    fig = plt.figure(figsize=(19, 9))
    # ax1 = fig.add_subplot(2, 2, (1, 3))
    # ax2 = fig.add_subplot(2, 2, 4)

    "Moving Average"
    MA_data = np.convolve(total_data,
                          np.ones((args.mv_size, )) / args.mv_size,
                          mode='valid')[:610]  # (818, 1)
    RUL_true = [(num, rms) for num, rms in enumerate(MA_data)
                if 9.0 <= rms <= 9.1][0][0]  # (818, 1)

    if args.type == 'linear':
        model = LinearRegression()
    elif args.type == 'exponential':
        model = Nonlinear_Regression()
    elif args.type == 'log':
        model = Nonlinear_Regression()
    elif args.type == 'lipow':
        model = Nonlinear_Regression()
    elif args.type == 'gom':
        model = Nonlinear_Regression()
    elif args.type == 'pow':
        model = Nonlinear_Regression()
    elif args.type == 'GP':
        kernel_RBF = kernels.ConstantKernel(1.0) * kernels.RBF(
            length_scale=1.0)
        model = GaussianProcessRegressor(kernel=kernel_RBF, alpha=0.4**2)
    else:
        assert print('Unsupported regression model', file=sys.stderr)

    for cnt, tc in sorted(enumerate(args.tc)):
        ax1 = fig.add_subplot(2, 2, (1, 3))
        ax2 = fig.add_subplot(2, 2, 4)

        observed_data = MA_data[:tc]

        time_curr_range = current_time(tc, args.n_window)
        time_pred_range = prediction_time(tc, args.n_window, args.range_pred)

        if np.prod(observed_data[time_curr_range] >= args.thld_fault):
            if args.type == 'linear':
                model.fit(time_curr_range[:, np.newaxis],
                          observed_data[time_curr_range])
                y_pred = model.predict(time_pred_range[:, np.newaxis])
                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

                ax1.plot(np.arange(tc - args.n_window, tc + args.range_pred),
                         y_pred, '.')
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred),
                             xy=(tc, 4.8),
                             fontsize=12,
                             color='red',
                             weight='bold')

            elif args.type == 'exponential':
                popt, _ = model.fit_exp(time_curr_range,
                                        observed_data[time_curr_range])
                y_pred = model.exponential_func(
                    prediction_time(tc, args.n_window, args.range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

            elif args.type == 'log':
                popt, _ = model.fit_log(time_curr_range,
                                        observed_data[time_curr_range])
                y_pred = model.log_func(
                    prediction_time(tc, args.n_window, args.range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

                ax1.plot(np.arange(tc - args.n_window, tc + args.range_pred),
                         y_pred)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred),
                             xy=(tc, 4.8),
                             fontsize=12,
                             color='red',
                             weight='bold')

            elif args.type == 'lipow':
                popt, _ = model.fit_lipow(time_curr_range,
                                          observed_data[time_curr_range])
                y_pred = model.lipow_func(
                    prediction_time(tc, args.n_window, args.range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

                ax1.plot(np.arange(tc - args.n_window, tc + args.range_pred),
                         y_pred)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred),
                             xy=(tc, 4.8),
                             fontsize=12,
                             color='red',
                             weight='bold')

            elif args.type == 'gom':
                popt, _ = model.fit_gom(time_curr_range,
                                        observed_data[time_curr_range])
                y_pred = model.gom_func(
                    prediction_time(tc, args.n_window, args.range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

                ax1.plot(np.arange(tc - args.n_window, tc + args.range_pred),
                         y_pred)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred),
                             xy=(tc, 4.8),
                             fontsize=12,
                             color='red',
                             weight='bold')

            elif args.type == 'pow':
                popt, _ = model.fit_pow(time_curr_range,
                                        observed_data[time_curr_range])
                y_pred = model.pow_func(
                    prediction_time(tc, args.n_window, args.range_pred), *popt)

                try:
                    RUL_pred = np.where(y_pred > args.thld_failure)[0][0] + (
                        tc - args.n_window)
                    RUL_preds += [RUL_pred]
                    print('Predicted RUL: {}m'.format(RUL_pred),
                          file=sys.stderr)
                except:
                    RUL_pred = 'Unestimatable'
                    RUL_preds += [RUL_preds[-1]]
                    print('Predicted RUL: {}'.format(RUL_pred),
                          file=sys.stderr)

                ax1.plot(np.arange(tc - args.n_window, tc + args.range_pred),
                         y_pred)
                ax1.annotate('Predicted RUL: {}'.format(RUL_pred),
                             xy=(tc, 4.8),
                             fontsize=12,
                             color='red',
                             weight='bold')

            elif args.type == 'GP':
                "MLE를 이용하여 데이터 fitting"
                model.fit(time_curr_range[:, np.newaxis],
                          observed_data[time_curr_range])
                "Compute posterior predictive mean and variance"
                mu_s, cov_s = model.predict(time_pred_range[:, np.newaxis],
                                            return_cov=True)
                samples = np.random.multivariate_normal(mu_s.ravel(), cov_s, 3)
                plot_gp(mu_s, cov_s, time_pred_range,
                        time_curr_range[:, np.newaxis], observed_data, samples)
        else:
            RUL_preds += [590 + args.tc[cnt]]

        ax1.set_title(
            'RUL prediction - linear regression |  time range: {}m ~ {}m'.
            format(tc - args.n_window, tc))
        ax1.plot(MA_data, '.', label='total data')
        ax1.plot(observed_data, '.', label='observed_data')

        ax1.text(0,
                 args.thld_safe + 0.05,
                 str(args.thld_safe),
                 color='c',
                 fontsize=13,
                 weight='bold')
        ax1.text(0,
                 args.thld_fault + 0.05,
                 str(args.thld_fault),
                 color='r',
                 fontsize=13,
                 weight='bold')
        ax1.text(0,
                 args.thld_failure + 0.05,
                 str(args.thld_failure),
                 color='r',
                 fontsize=13,
                 weight='bold')

        ax1.axvline(x=tc - args.n_window)
        ax1.axvline(x=tc)
        ax1.axhline(y=args.thld_safe,
                    color='c',
                    linestyle='-',
                    label='Threshold safe')
        ax1.axhline(y=args.thld_fault,
                    color='r',
                    linestyle='--',
                    label='Threshold fault')
        ax1.axhline(y=args.thld_failure,
                    color='r',
                    linestyle='-',
                    label='Threshold failure')

        ax1.axvspan(tc - args.n_window, tc, facecolor='gray', alpha=0.5)

        ax1.set_xlabel('Times (m)')
        ax1.set_ylabel('RMS')
        ax1.set_xlim([-10, 900])
        ax1.set_ylim([min(observed_data) - 0.2, 10])
        ax1.annotate('True RUL: {}'.format(RUL_true),
                     xy=(tc, 5),
                     fontsize=12,
                     weight='bold')

        ax2.set_title('RUL curve')
        ax2.set_xlabel('Times (m)')
        ax2.set_ylabel('RUL')
        ax2.set_xlim([-10, RUL_true + 20])
        ax2.set_ylim([-10, RUL_true + 20])
        ax2.plot([0, RUL_true], [RUL_true, 0], label='True RUL curve')
        ax2.plot(args.tc[:len(RUL_preds)],
                 np.array(RUL_preds) - args.tc[:len(RUL_preds)],
                 label='predicted RUL curve')

        ax1.legend(loc='upper left', bbox_to_anchor=(0.01, 0.6))
        ax2.legend(loc='upper left', bbox_to_anchor=(0.01, 0.6))

        plt.tight_layout()
        plt.pause(0.1)
        plt.clf()
    os.system('pause')