In [1]:

    

from IPython.parallel import Client
parallel_client = Client()
ldview = parallel_client.load_balanced_view()


    

In [2]:

    

#load magics in current kernel
%matplotlib inline
%pylab inline
%load_ext autoreload
%autoreload 2


    

    




Populating the interactive namespace from numpy and matplotlib

In [3]:

    

%%px --noblock
#load magics in clusters
%matplotlib inline
%pylab inline
%load_ext autoreload
%autoreload 2


    

    
Out[3]:





<AsyncResult: execute>

In [5]:

    

#initialize experiments in current kernel
%run experiments_init.py


    

    




C:\Anaconda\lib\site-packages\sklearn\pls.py:7: DeprecationWarning: This module has been moved to cross_decomposition and will be removed in 0.16
  "removed in 0.16", DeprecationWarning)

In [6]:

    

%%px --noblock
#initialize experiments in clusters
%run experiments_init.py


    

    
Out[6]:





<AsyncResult: execute>

In [124]:

    

def run_amgng_mackey_glass_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1

    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             modify_time_domain=True, gamma=gamma, e_w=e_w, e_n=e_n)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mackey_glass_time_noise = ldview.map_async(run_amgng_mackey_glass_time_noise, [0])


    

In [22]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_mackey-glass_time_noise_150000_wide.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_mackey_glass_time_noise.ready():
    #ret_val = amgng_mackey_glass_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
    #signal.to_csv('experiments/oger/out_amgng_mackey-glass_time_noise_150000_wide.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld, 'anomaly_score', 'A', 'Annotation', increase_start, decrease_stop, plot_score=False)
    plot_signal(signal, max_threshld, 'anomaly_score', 'A', 'Annotation', 1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000), annotate_scores=False, plot_score=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.540981124468;
Detected: 1743;
True Positives: 1638;
False Positives: 105;
False Negatives: 162;
Precision: 0.939759036145;
Recall: 0.91;
F1: 0.924640135478
Score (mean, std.) before change: (0.12816882184, 0.0812305789194);
Score (mean, std.) after change: (0.0364823277725, 0.0281505489617);
Score (mean, std.) before change 100: (0.128340860527, 0.0811491472724);
Score (mean, std.) before change 1000: (0.128779312719, 0.0809449043956);
Score (mean, std.) before change 10000: (0.124077183557, 0.0769175603969);

Score (mean, std.) during change: (1.0053668799, 0.402378001592)

Score (mean, std.) after change 100: (0.0361498291569, 0.0249681622019);
Score (mean, std.) after change 1000: (0.0350174812263, 0.0215120908947);
Score (mean, std.) after change 10000: (0.0311460658595, 0.0121473438796);







    













    













    

In [197]:

    

def run_cla_mackey_glass_time_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    #trans = np.fft.fftn(signal.iloc[increase_start:decrease_stop])
    #noise = trans + 2*np.random.randn(modification_len, dimensions)
    #itrans = np.fft.ifftn(noise).real
    #signal.iloc[increase_start:decrease_stop] = itrans
    signal.iloc[increase_start:decrease_stop] = np.random.randn(modification_len, dimensions)

    file_name = 'cla_mackey_glass_time_noise_3.csv'
    cwd = 'experiments/oger/'
    name = 'mackey_glass_time_noise'
    with Capturing() as output:
        signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                           signal=signal, buffer_len=buffer_len,
                           increase_start=increase_start,
                           decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mackey_glass_time_noise = ldview.map(run_cla_mackey_glass_time_noise, [0])


    

In [23]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_mackey-glass_time_noise_150000_wide.csv',
                              index_col='step', low_memory=False)
    }

#if cla_mackey_glass_time_noise.ready():
if True:
#    ret_val = cla_mackey_glass_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_cla_mackey-glass_time_noise_150000_wide.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld, 'anomaly_likelihood', 'A', 'Annotation', increase_start, decrease_stop)
    plot_signal(signal, max_threshld, 'anomaly_likelihood', 'A', 'Annotation', 1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000), annotate_scores=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.929121100425;
Detected: 1797;
True Positives: 1767;
False Positives: 30;
False Negatives: 33;
Precision: 0.983305509182;
Recall: 0.981666666667;
F1: 0.982485404504
Score (mean, std.) before change: (0.355107675188, 0.113077003868);
Score (mean, std.) after change: (0.353942647444, 0.0619469685541);
Score (mean, std.) before change 100: (0.354913188846, 0.113028112508);
Score (mean, std.) before change 1000: (0.35347183007, 0.112525834174);
Score (mean, std.) before change 10000: (0.335427065354, 0.0906699879477);

Score (mean, std.) during change: (0.994094360029, 0.017052868724)

Score (mean, std.) after change 100: (0.353636151126, 0.0611179970058);
Score (mean, std.) after change 1000: (0.352969443199, 0.0605587413423);
Score (mean, std.) after change 10000: (0.351869894085, 0.059479234209);







    













    













    

In [142]:

    

def run_amgng_mackey_glass_fix_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1

    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[-1, -1, -2, -2],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mackey_glass_fix_time_noise = ldview.map(run_amgng_mackey_glass_fix_time_noise, [0])


    

In [27]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_mackey-glass_fix_time_noise_150000.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_mackey_glass_fix_time_noise.ready():
#    ret_val = amgng_mackey_glass_fix_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_amgng_mackey-glass_fix_time_noise_150000.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop, plot_score=False)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.856320527535;
Detected: 1500;
True Positives: 1377;
False Positives: 123;
False Negatives: 423;
Precision: 0.918;
Recall: 0.765;
F1: 0.834545454545
Score (mean, std.) before change: (0.17479396726, 0.109870118547);
Score (mean, std.) before change 100: (0.175028590035, 0.10975691414);
Score (mean, std.) before change 1000: (0.176037953476, 0.109598518126);
Score (mean, std.) before change 10000: (0.176563369597, 0.110037457464);
Score (mean, std.) during change: (1.74103124208, 1.04491689611);
Score (mean, std.) after change: (0.177977357202, 0.119721347243);
Score (mean, std.) after change 100: (0.176303080603, 0.110084271445);
Score (mean, std.) after change 1000: (0.176293213154, 0.109827661982);
Score (mean, std.) after change 10000: (0.177483167557, 0.109522828414);







    













    













    

In [46]:

    

def run_cla_mackey_glass_fix_time_noise_4(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[-1, -1, -2, -2],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    #trans = np.fft.fftn(signal.iloc[increase_start:decrease_stop])
    #noise = trans + 2*np.random.randn(modification_len, dimensions)
    #itrans = np.fft.ifftn(noise).real
    #signal.iloc[increase_start:decrease_stop] = itrans
    #signal.iloc[increase_start:decrease_stop] = np.random.randn(modification_len, dimensions)

    file_name = 'cla_mackey_glass_fix_time_noise.csv'
    cwd = 'experiments/oger/'
    name = 'mackey_glass_fix_time_noise'
    with Capturing() as output:
        signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                           signal=signal, buffer_len=buffer_len,
                           increase_start=increase_start,
                           decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mackey_glass_fix_time_noise_4 = ldview.map(run_cla_mackey_glass_fix_time_noise_4, [0])


    

In [28]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_mackey-glass_fix_time_noise_150000.csv',
                              index_col='step', low_memory=False)
    }
if True:
# if cla_mackey_glass_fix_time_noise_4.ready():
    #ret_val = cla_mackey_glass_fix_time_noise_4.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#     signal.to_csv('experiments/oger/out_cla_mackey-glass_fix_time_noise_150000.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop)
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.661093632223;
Detected: 2281;
True Positives: 807;
False Positives: 1474;
False Negatives: 993;
Precision: 0.353792196405;
Recall: 0.448333333333;
F1: 0.395491301152
Score (mean, std.) before change: (0.355107675188, 0.113077003868);
Score (mean, std.) before change 100: (0.354913188846, 0.113028112508);
Score (mean, std.) before change 1000: (0.35347183007, 0.112525834174);
Score (mean, std.) before change 10000: (0.335427065354, 0.0906699879477);
Score (mean, std.) during change: (0.631072818048, 0.1710975645);
Score (mean, std.) after change: (0.327013827393, 0.0769274702713);
Score (mean, std.) after change 100: (0.326772440118, 0.0764950949617);
Score (mean, std.) after change 1000: (0.325774288387, 0.0754391100031);
Score (mean, std.) after change 10000: (0.323375591661, 0.0722177730404);







    













    













    

In [146]:

    

def run_amgng_mackey_glass_freq_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             modify_freq_domain=True, gamma=gamma, e_w=e_w, e_n=e_n)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mackey_glass_freq_noise = ldview.map(run_amgng_mackey_glass_freq_noise, [0])


    

In [29]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_mackey-glass_freq_noise_150000.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_mackey_glass_freq_noise.ready():
#    ret_val = amgng_mackey_glass_freq_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_amgng_mackey-glass_freq_noise_150000.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop, plot_score=False)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.343383356777;
Detected: 2568;
True Positives: 94;
False Positives: 2474;
False Negatives: 1706;
Precision: 0.0366043613707;
Recall: 0.0522222222222;
F1: 0.0430402930403
Score (mean, std.) before change: (0.12816882184, 0.0812305789194);
Score (mean, std.) before change 100: (0.128340860527, 0.0811491472724);
Score (mean, std.) before change 1000: (0.128779312719, 0.0809449043956);
Score (mean, std.) before change 10000: (0.124077183557, 0.0769175603969);
Score (mean, std.) during change: (0.136898520728, 0.0922887643129);
Score (mean, std.) after change: (0.106313098442, 0.0670091756254);
Score (mean, std.) after change 100: (0.106318427493, 0.0670197167287);
Score (mean, std.) after change 1000: (0.106259537649, 0.067085648415);
Score (mean, std.) after change 10000: (0.10591506108, 0.0666316362599);







    













    













    

In [532]:

    

signal = pd.read_csv('experiments/oger/out_amgng_mackey-glass_freq_noise_150000.csv',
                     index_col='step', low_memory=False)
increase_start = 74600
decrease_stop = 76400
figure()
subseq = signal[increase_start-1000:increase_start]
ax = subplot(2, 1, 1)
subseq.iloc[:,0].plot(ax=ax)
ax.set_ylabel('clean time series')
subseq = signal[increase_start:increase_start+1000]
ax = subplot(2, 1, 2)
subseq.iloc[:,1].plot(ax=ax)
ax.set_ylabel('time series with noise')


    

    
Out[532]:





<matplotlib.text.Text at 0x7f7cebca6050>






    

In [64]:

    

def run_cla_mackey_glass_freq_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    trans = np.fft.fftn(signal.iloc[increase_start:decrease_stop])
    noise = trans + 2*np.random.randn(modification_len, dimensions)
    itrans = np.fft.ifftn(noise).real
    signal.iloc[increase_start:decrease_stop] = itrans

    file_name = 'cla_mackey-glass_freq_input.csv'
    cwd = 'experiments/oger/'
    name = 'mackey_glass_freq_noise'
    with Capturing() as output:
        signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                           signal=signal, buffer_len=buffer_len,
                           increase_start=increase_start,
                           decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mackey_glass_freq_noise = ldview.map(run_cla_mackey_glass_freq_noise, [0])


    

In [30]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_mackey-glass_freq_noise_150000.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if cla_mackey_glass_freq_noise.ready():
    #ret_val = cla_mackey_glass_freq_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
    #signal.to_csv('experiments/oger/out_cla_mackey-glass_freq_noise_150000.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop)
    plot_signal(signal, max_threshld,
            'anomaly_likelihood', 'A', 'Annotation',
            1000, 1000 + (decrease_stop-increase_start),
            slce=slice(increase_start-1000, decrease_stop+1000),
            annotate_scores=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.772320224341;
Detected: 2104;
True Positives: 1600;
False Positives: 504;
False Negatives: 200;
Precision: 0.760456273764;
Recall: 0.888888888889;
F1: 0.819672131148
Score (mean, std.) before change: (0.355107675188, 0.113077003868);
Score (mean, std.) before change 100: (0.354913188846, 0.113028112508);
Score (mean, std.) before change 1000: (0.35347183007, 0.112525834174);
Score (mean, std.) before change 10000: (0.335427065354, 0.0906699879477);
Score (mean, std.) during change: (0.880056966221, 0.0869293322894);
Score (mean, std.) after change: (0.355372041196, 0.0749776400554);
Score (mean, std.) after change 100: (0.355242984056, 0.0748206083378);
Score (mean, std.) after change 1000: (0.354981797299, 0.0747530639075);
Score (mean, std.) after change 10000: (0.35409635788, 0.0742971653149);







    













    













    

In [170]:

    

def run_amgng_random_ts_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_memtest(increase_start, increase_stop,
                                                             decrease_start, decrease_stop,
                                                             n_samples=dimensions,
                                                             sample_len=sample_len,
                                                             increases=[0, 0, 0, 0])
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    signal.iloc[increase_start:decrease_stop] = np.random.randn(modification_len, dimensions)
    with Capturing() as output:
        signal = train_amgng(signal=signal, dimensions=dimensions, buffer_len=buffer_len,
                             ma_window=ma_window, ma_recalc_delay=ma_recalc_delay,
                             increase_start=increase_start, decrease_stop=decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_random_ts_time_noise = ldview.map(run_amgng_random_ts_time_noise, [0])


    

In [31]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_random_ts_time_noise.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_random_ts_time_noise.ready():
#    ret_val = amgng_random_ts_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_amgng_random_ts_time_noise.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop, plot_score=False)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 0.908555517735;
Detected: 2740;
True Positives: 961;
False Positives: 1779;
False Negatives: 839;
Precision: 0.350729927007;
Recall: 0.533888888889;
F1: 0.423348017621
Score (mean, std.) before change: (0.684941757825, 0.098289576383);
Score (mean, std.) before change 100: (0.685861142735, 0.0950958975044);
Score (mean, std.) before change 1000: (0.688468043285, 0.0837593610162);
Score (mean, std.) before change 10000: (0.680029375358, 0.0664572031739);
Score (mean, std.) during change: (0.920249061586, 0.0874868911795);
Score (mean, std.) after change: (0.717179439035, 0.0560293952488);
Score (mean, std.) after change 100: (0.7172207554, 0.0559382074762);
Score (mean, std.) after change 1000: (0.719061433107, 0.0536293353052);
Score (mean, std.) after change 10000: (0.728125390413, 0.0473166279512);







    













    













    

In [231]:

    

def run_cla_random_ts_time_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_memtest(increase_start, increase_stop,
                                                             decrease_start, decrease_stop,
                                                             n_samples=dimensions,
                                                             sample_len=sample_len,
                                                             increases=[0, 0, 0, 0])
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    signal.iloc[increase_start:decrease_stop] = np.random.randn(modification_len, dimensions)
    file_name = 'cla_random_ts_time_input.csv'
    cwd = 'experiments/oger/'
    name = 'random_ts_time_noise'
    signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                       signal=signal, buffer_len=buffer_len,
                       increase_start=increase_start,
                       decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_random_ts_time_noise = ldview.map(run_cla_random_ts_time_noise, [0])


    

In [32]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_random_ts_time_noise.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if cla_random_ts_time_noise.ready():
#    ret_val = cla_random_ts_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_cla_random_ts_time_noise.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop)
    plot_signal(signal, max_threshld,
            'anomaly_likelihood', 'A', 'Annotation',
            1000, 1000 + (decrease_stop-increase_start),
            slce=slice(increase_start-1000, decrease_stop+1000),
            annotate_scores=False)
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.14096469319;
Detected: 139218;
True Positives: 1776;
False Positives: 137442;
False Negatives: 24;
Precision: 0.0127569710813;
Recall: 0.986666666667;
F1: 0.0251882738374
Score (mean, std.) before change: (0.251839434582, 0.121918617601);
Score (mean, std.) before change 100: (0.251506333152, 0.121660703422);
Score (mean, std.) before change 1000: (0.249942681894, 0.120446074971);
Score (mean, std.) before change 10000: (0.23039720522, 0.0969614697275);
Score (mean, std.) during change: (0.232585863501, 0.0704149306441);
Score (mean, std.) after change: (0.300116169681, 0.0894417321072);
Score (mean, std.) after change 100: (0.300281108075, 0.0893808762392);
Score (mean, std.) after change 1000: (0.301929933347, 0.0886329876341);
Score (mean, std.) after change 10000: (0.31791180074, 0.0810617963026);







    













    













    

In [18]:

    

def run_amgng_random_ts_fix_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_memtest(increase_start, increase_stop,
                                                             decrease_start, decrease_stop,
                                                             n_samples=dimensions,
                                                             sample_len=sample_len,
                                                             increases=[-1, -1, -2, -2])
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    with Capturing() as output:
        signal = train_amgng(signal=signal, dimensions=dimensions, buffer_len=buffer_len,
                             ma_window=ma_window, ma_recalc_delay=ma_recalc_delay,
                             increase_start=increase_start, decrease_stop=decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_random_ts_fix_time_noise = ldview.map(run_amgng_random_ts_fix_time_noise, [0])


    

In [33]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_random_ts_fix_time_noise.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_random_ts_fix_time_noise.ready():
#    ret_val = amgng_random_ts_fix_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_amgng_random_ts_fix_time_noise.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop, plot_score=False)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False)
else:
    print('Not ready')


    

    




Real: 1800;
Threshold: 1.14299148609;
Detected: 1080;
True Positives: 946;
False Positives: 134;
False Negatives: 854;
Precision: 0.875925925926;
Recall: 0.525555555556;
F1: 0.656944444444
Score (mean, std.) before change: (0.648632135283, 0.0927797486078);
Score (mean, std.) before change 100: (0.649502782445, 0.0897448663409);
Score (mean, std.) before change 1000: (0.650715896165, 0.0753808461606);
Score (mean, std.) before change 10000: (0.654370724694, 0.0573953423167);
Score (mean, std.) during change: (1.12826770081, 0.386045624775);
Score (mean, std.) after change: (0.718321054883, 0.0467353177386);
Score (mean, std.) after change 100: (0.717851227085, 0.0449068160217);
Score (mean, std.) after change 1000: (0.718740131154, 0.0430383615143);
Score (mean, std.) after change 10000: (0.726198542809, 0.0381773416232);







    













    













    

In [51]:

    

def run_cla_random_ts_fix_time_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_memtest(increase_start, increase_stop,
                                                             decrease_start, decrease_stop,
                                                             n_samples=dimensions,
                                                             sample_len=sample_len,
                                                             increases=[-1, -1, -2, -2])
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    file_name = 'cla_random_ts_fix_time_input.csv'
    cwd = 'experiments/oger/'
    name = 'random_ts_fix_time_noise'
    signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                       signal=signal, buffer_len=buffer_len,
                       increase_start=increase_start,
                       decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_random_ts_fix_time_noise = ldview.map(run_cla_random_ts_fix_time_noise, [0])


    

In [34]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_random_ts_fix_time_noise.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if cla_random_ts_fix_time_noise.ready():
#    ret_val = cla_random_ts_fix_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#    signal.to_csv('experiments/oger/out_cla_random_ts_fix_time_noise.csv')
    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop)
    plot_signal(signal, max_threshld,
            'anomaly_likelihood', 'A', 'Annotation',
            1000, 1000 + (decrease_stop-increase_start),
            slce=slice(increase_start-1000, decrease_stop+1000),
            annotate_scores=False)
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.135841754685;
Detected: 142885;
True Positives: 1776;
False Positives: 141109;
False Negatives: 24;
Precision: 0.0124295762326;
Recall: 0.986666666667;
F1: 0.0245498842313
Score (mean, std.) before change: (0.251413527781, 0.120209338056);
Score (mean, std.) before change 100: (0.251079854664, 0.119944247449);
Score (mean, std.) before change 1000: (0.249590445968, 0.118635621051);
Score (mean, std.) before change 10000: (0.228334846357, 0.0921654657464);
Score (mean, std.) during change: (0.205781583063, 0.0434375238959);
Score (mean, std.) after change: (0.280834941562, 0.0784877785978);
Score (mean, std.) after change 100: (0.280819438815, 0.0785007332368);
Score (mean, std.) after change 1000: (0.280748997732, 0.0786641347157);
Score (mean, std.) after change 10000: (0.285330088939, 0.0796371579564);







    













    













    

In [14]:

    

def run_amgng_mixed_mackey_glass_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    ddof = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=2,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0],
                                                                  seed=0)
    r_signal, _ = signal_generation.generate_memtest(increase_start, increase_stop,
                                                     decrease_start, decrease_stop,
                                                     n_samples=2,
                                                     sample_len=sample_len,
                                                     increases=[0, 0])
    signal[['signal_150000_samples_2d', 'signal_150000_samples_3d']] = r_signal
    signal.iloc[:,[1, 3]] *= -2
    signal.iloc[increase_start:decrease_stop, 0] = np.random.randn(modification_len)

    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n, ddof=ddof)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mixed_mackey_glass_time_noise = ldview.map_async(run_amgng_mixed_mackey_glass_time_noise, [0])


    

In [35]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 200,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_mixed_mackey-glass_time_noise.csv',
                              index_col='step', low_memory=False),
}
if True:
#if amgng_mixed_mackey_glass_time_noise.ready():
#    ret_val = amgng_mixed_mackey_glass_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal = signal.rename(columns={'signal_150000_samples_0d': 'MG1', 'signal_150000_samples_1d': 'MG2',
#                           'signal_150000_samples_2d': 'R1', 'signal_150000_samples_3d': 'R2'})
#    signal.to_csv('experiments/oger/out_amgng_mixed_mackey-glass_time_noise.csv')

    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop,
                plot_score=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.66806562324;
Detected: 2757;
True Positives: 1413;
False Positives: 1344;
False Negatives: 387;
Precision: 0.512513601741;
Recall: 0.785;
F1: 0.620144832126
Score (mean, std.) before change: (0.4494874536, 0.0787833004162);
Score (mean, std.) before change 100: (0.450090792464, 0.0770946101247);
Score (mean, std.) before change 1000: (0.451471397058, 0.0704693588499);
Score (mean, std.) before change 10000: (0.44020064605, 0.0507637160092);
Score (mean, std.) during change: (0.714992517224, 0.0585891497369);
Score (mean, std.) after change: (0.429739020966, 0.0261664831341);
Score (mean, std.) after change 100: (0.429469038241, 0.0250782195722);
Score (mean, std.) after change 1000: (0.429456292889, 0.0248725569589);
Score (mean, std.) after change 10000: (0.430344435004, 0.0242149979127);







    













    













    

In [26]:

    

signal = pd.read_csv('experiments/oger/out_amgng_mixed_mackey-glass_time_noise.csv',
                     index_col='step', low_memory=False)
increase_start = 74600
decrease_stop = 76400
figure()
subseq = signal[increase_start-1000:decrease_stop+1000]
ax = subplot(3, 1, 1)
subseq.iloc[:,:4].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('signals')
ax = subplot(3, 2, 3)
subseq.iloc[:,0].plot(ax=ax, alpha=0.5, ylim=(-4,4),)
ax.set_ylabel('MG1')
ax = subplot(3, 2, 4)
subseq.iloc[:,1].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('MG2')
ax = subplot(3, 2, 5)
subseq.iloc[:,2].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('R1')
ax = subplot(3, 2, 6)
subseq.iloc[:,3].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('R2')


    

    
Out[26]:





<matplotlib.text.Text at 0x17b0ef60>






    

In [13]:

    

def run_cla_mixed_mackey_glass_time_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=2,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0],
                                                                  seed=0)
    r_signal, _ = signal_generation.generate_memtest(increase_start, increase_stop,
                                                     decrease_start, decrease_stop,
                                                     n_samples=2,
                                                     sample_len=sample_len,
                                                     increases=[0, 0])
    signal[['signal_150000_samples_2d', 'signal_150000_samples_3d']] = r_signal
    signal.iloc[:,[1, 3]] *= -2
    signal.iloc[increase_start:decrease_stop, 0] = np.random.randn(modification_len)

    file_name = 'cla_mixed_mackey-glass_time_noise_input.csv'
    cwd = 'experiments/oger/'
    name = 'mixed_mackey-glass_time_noise'
    signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                       signal=signal, buffer_len=buffer_len,
                       increase_start=increase_start,
                       decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mixed_mackey_glass_time_noise = ldview.map_async(run_cla_mixed_mackey_glass_time_noise, [0])


    

In [36]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_mixed_mackey-glass_time_noise.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if cla_mixed_mackey_glass_time_noise.ready():
#    ret_val = cla_mixed_mackey_glass_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#    signal = signal.rename(columns={'signal_150000_samples_0d': 'MG1', 'signal_150000_samples_1d': 'MG2',
#                           'signal_150000_samples_2d': 'R1', 'signal_150000_samples_3d': 'R2'})
#    signal.to_csv('experiments/oger/out_cla_mixed_mackey-glass_time_noise.csv')

    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.408451741342;
Detected: 16452;
True Positives: 1365;
False Positives: 15087;
False Negatives: 435;
Precision: 0.0829686360321;
Recall: 0.758333333333;
F1: 0.149572649573
Score (mean, std.) before change: (0.30430120403, 0.109057157126);
Score (mean, std.) before change 100: (0.304038521082, 0.108894222461);
Score (mean, std.) before change 1000: (0.302793099924, 0.108105614622);
Score (mean, std.) before change 10000: (0.282920281395, 0.0860779196267);
Score (mean, std.) during change: (0.449052708976, 0.0548983668049);
Score (mean, std.) after change: (0.29483952181, 0.059658075834);
Score (mean, std.) after change 100: (0.294817079462, 0.0596419224436);
Score (mean, std.) after change 1000: (0.295019279603, 0.0595639291441);
Score (mean, std.) after change 10000: (0.295597900468, 0.0580190793189);







    













    













    

In [9]:

    

def run_amgng_mixed_random_time_noise(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    ddof = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=2,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0],
                                                                  seed=0)
    r_signal, _ = signal_generation.generate_memtest(increase_start, increase_stop,
                                                     decrease_start, decrease_stop,
                                                     n_samples=2,
                                                     sample_len=sample_len,
                                                     increases=[0, 0])
    signal[['signal_150000_samples_2d', 'signal_150000_samples_3d']] = r_signal
    signal.iloc[:,[1, 3]] *= -2
    signal.iloc[increase_start:decrease_stop, 2] = np.random.randn(modification_len)

    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n, ddof=ddof)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mixed_random_time_noise = ldview.map_async(run_amgng_mixed_random_time_noise, [0])


    

In [37]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'ma_window': 38000,
        'signal': pd.read_csv('experiments/oger/out_amgng_mixed_random_time_noise.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if amgng_mixed_random_time_noise.ready():
#    ret_val = amgng_mixed_random_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
#    signal = signal.rename(columns={'signal_150000_samples_0d': 'MG1', 'signal_150000_samples_1d': 'MG2',
#                           'signal_150000_samples_2d': 'R1', 'signal_150000_samples_3d': 'R2'})
#    signal.to_csv('experiments/oger/out_amgng_mixed_random_time_noise.csv')

    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_scores(xs, f1, precision, recall)
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                increase_start, decrease_stop,
                plot_score=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
    plot_signal(signal, max_threshld,
                'anomaly_score', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False, plot_score=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.627881224849;
Detected: 3541;
True Positives: 1500;
False Positives: 2041;
False Negatives: 300;
Precision: 0.423609149958;
Recall: 0.833333333333;
F1: 0.561692566935
Score (mean, std.) before change: (0.4494874536, 0.0787833004162);
Score (mean, std.) before change 100: (0.450090792464, 0.0770946101247);
Score (mean, std.) before change 1000: (0.451471397058, 0.0704693588499);
Score (mean, std.) before change 10000: (0.44020064605, 0.0507637160092);
Score (mean, std.) during change: (0.674273042213, 0.0562137375044);
Score (mean, std.) after change: (0.431473413077, 0.0250163360901);
Score (mean, std.) after change 100: (0.431266976557, 0.0243578110018);
Score (mean, std.) after change 1000: (0.431134349731, 0.0241414807687);
Score (mean, std.) after change 10000: (0.431565179214, 0.0236492082643);







    













    













    

In [17]:

    

signal = pd.read_csv('experiments/oger/out_amgng_mixed_random_time_noise.csv',
                     index_col='step', low_memory=False)
increase_start = 74600
decrease_stop = 76400
figure()
subseq = signal[increase_start-1000:decrease_stop+1000]
ax = subplot(3, 1, 1)
subseq.iloc[:,:4].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('signals')
ax = subplot(3, 2, 3)
subseq.iloc[:,0].plot(ax=ax, alpha=0.5, ylim=(-4,4),)
ax.set_ylabel('MG1')
ax = subplot(3, 2, 4)
subseq.iloc[:,1].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('MG2')
ax = subplot(3, 2, 5)
subseq.iloc[:,2].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('R1')
ax = subplot(3, 2, 6)
subseq.iloc[:,3].plot(ax=ax, alpha=0.5, ylim=(-4,4))
ax.set_ylabel('R2')


    

    
Out[17]:





<matplotlib.text.Text at 0x1f8d1940>






    

In [511]:

    

def run_cla_mixed_random_time_noise(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=2,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0],
                                                                  seed=0)
    r_signal, _ = signal_generation.generate_memtest(increase_start, increase_stop,
                                                     decrease_start, decrease_stop,
                                                     n_samples=2,
                                                     sample_len=sample_len,
                                                     increases=[0, 0])
    signal[['signal_150000_samples_2d', 'signal_150000_samples_3d']] = r_signal
    signal.iloc[:,[1, 3]] *= -2
    signal.iloc[increase_start:decrease_stop, 2] = np.random.randn(modification_len)

    file_name = 'cla_mixed_random_time_noise_input.csv'
    cwd = 'experiments/oger/'
    name = 'mixed_random_time_noise'
    signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                       signal=signal, buffer_len=buffer_len,
                       increase_start=increase_start,
                       decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mixed_random_time_noise = ldview.map_async(run_cla_mixed_random_time_noise, [0])


    

In [38]:

    

ret_val = {
        'increase_start': 74600,
        'decrease_stop': 76400,
        'buffer_len': 400,
        'signal': pd.read_csv('experiments/oger/out_cla_mixed_random_time_noise.csv',
                              index_col='step', low_memory=False)
    }
if True:
#if cla_mixed_random_time_noise.ready():
#    ret_val = cla_mixed_random_time_noise.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    signal = ret_val['signal']
#    signal = signal.rename(columns={'signal_150000_samples_0d': 'MG1', 'signal_150000_samples_1d': 'MG2',
#                           'signal_150000_samples_2d': 'R1', 'signal_150000_samples_3d': 'R2'})
#    signal.to_csv('experiments/oger/out_cla_mixed_random_time_noise.csv')

    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_likelihood', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_likelihood')
    plot_scores(xs, f1, precision, recall, 'anomaly_likelihood')
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                increase_start, decrease_stop,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
    plot_signal(signal, max_threshld,
                'anomaly_likelihood', 'A', 'Annotation',
                1000, 1000 + (decrease_stop-increase_start),
                slce=slice(increase_start-1000, decrease_stop+1000),
                annotate_scores=False,
                signal_columns=['MG1', 'MG2', 'R1', 'R2'])
else:
    print('{} Not ready'.format(datetime.now()))


    

    




Real: 1800;
Threshold: 0.196661949535;
Detected: 139910;
True Positives: 1732;
False Positives: 138178;
False Negatives: 68;
Precision: 0.0123793867486;
Recall: 0.962222222222;
F1: 0.0244442876297
Score (mean, std.) before change: (0.30430120403, 0.109057157126);
Score (mean, std.) before change 100: (0.304038521082, 0.108894222461);
Score (mean, std.) before change 1000: (0.302793099924, 0.108105614622);
Score (mean, std.) before change 10000: (0.282920281395, 0.0860779196267);
Score (mean, std.) during change: (0.286144887517, 0.0634909518657);
Score (mean, std.) after change: (0.337378362618, 0.0770785854358);
Score (mean, std.) after change 100: (0.337434767949, 0.0770993227127);
Score (mean, std.) after change 1000: (0.338319872319, 0.0768904764938);
Score (mean, std.) after change 10000: (0.344623964758, 0.0761322518838);







    













    













    

In [10]:

    

def run_amgng_mackey_glass_shift(x):
    dimensions = 4
    buffer_len = 200
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    gamma = 88
    e_w = 0.4
    e_n = 0.05
    ma_window = 38000
    ma_recalc_delay = 1
    ddof = 1
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    signal.iloc[increase_start:, 0] += 5
    signal.iloc[increase_start:, 1] -= 5
    signal.iloc[increase_start:, 2] += 10
    signal.iloc[increase_start:, 3] -= 10

    with Capturing() as output:
        signal = train_amgng(signal, dimensions, buffer_len, ma_window,
                             ma_recalc_delay, increase_start, decrease_stop,
                             gamma=gamma, e_w=e_w, e_n=e_n, ddof=ddof)


    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'ma_window': ma_window,
        'signal': signal,
    }
    return ret_val

amgng_mackey_glass_shift = ldview.map_async(run_amgng_mackey_glass_shift, [0])


    

In [ ]:

    

#ret_val = {
#        'increase_start': 74600,
#        'decrease_stop': 76400,
#        'buffer_len': 400,
#        'signal': pd.read_csv('experiments/oger/out_amgng_mackey-glass_shift.csv',
#                              index_col='step', low_memory=False)
#    }
#if True:
if amgng_mackey_glass_shift.ready():
    ret_val = amgng_mackey_glass_shift.result[0]
    increase_start = ret_val['increase_start']
    decrease_stop = ret_val['decrease_stop']
    buffer_len = ret_val['buffer_len']
    ma_window = ret_val['ma_window']
    signal = ret_val['signal']
    signal.to_csv('experiments/oger/out_amgng_mackey-glass_shift.csv')

    xs, f1, precision, recall, max_threshld = print_f1_stats(signal=signal, density_column='anomaly_score', regex='A')
    print_shift_stats(signal=signal, shift_start=increase_start, shift_end=decrease_stop, column='anomaly_score')
    plot_signal(signal, 0,
                'anomaly_score', 'A', 'Annotation',
                0, 0,
                annotate_scores=False, plot_score=False,
                plot_threshold=False)
    plot_signal(signal, 0,
                'anomaly_score', 'A', 'Annotation',
                0, 0,
                slce=slice(increase_start-1500, increase_start+1500),
                annotate_scores=False, plot_score=False,
                plot_threshold=False)
else:
    print('{} Not ready'.format(datetime.now()))


    

In [268]:

    

def run_cla_mackey_glass_shift(x):
    dimensions = 4
    buffer_len = 400
    sample_len = 150000
    increase_start = 74600
    increase_stop = 75400
    decrease_start = 75600
    decrease_stop = 76400
    modification_len = decrease_stop - increase_start
    signal, annotations = signal_generation.generate_mackey_glass(increase_start, increase_stop,
                                                                  decrease_start, decrease_stop,
                                                                  n_samples=dimensions,
                                                                  sample_len=sample_len,
                                                                  increases=[0, 0, 0, 0],
                                                                  seed=0)
    signal.iloc[:,1] *= -1
    signal.iloc[:,2] *= 2
    signal.iloc[:,3] *= -2
    signal.iloc[increase_start:, 0] += 5
    signal.iloc[increase_start:, 1] -= 5
    signal.iloc[increase_start:, 2] += 10
    signal.iloc[increase_start:, 3] -= 10

    file_name = 'cla_mackey-glass_shift_input.csv'
    cwd = 'experiments/oger/'
    name = 'mackey_glass_shift'
    signal = train_cla(name=name, cwd=cwd, file_name=file_name,
                       signal=signal, buffer_len=buffer_len,
                       increase_start=increase_start,
                       decrease_stop=decrease_stop)

    ret_val = {
        'increase_start': increase_start,
        'decrease_stop': decrease_stop,
        'buffer_len': buffer_len,
        'signal': signal,
    }
    return ret_val

cla_mackey_glass_shift = ldview.map_async(run_cla_mackey_glass_shift, [0])