Greetings.

I believe there is a minor mistake on the scaling done on the hamming method, it should be n_samples*(n_samples-1).

I also provided an additional implementation of the Rand index under the method randindex_cpd. This implementation is based on an specific expression for the metric on change-point problems. If we have N samples and change-point sets of size r and s, this algorithm runs on O(r+s) in time and O(1) in memory complexity. The traditional implementation runs on O(rs+N) in time and O(rs) in memory, albeit your implementation might use less due to sparsity. This new implementation seems to perform some orders of magnitude better, depending on N, in a few profiling that I did.

I can provide the proof of correctness of the algorithm if requested.

Thanks.

The GH action that releases to PyPI run pytest ruptures/tests (see here) which requires pytest-cov (specified here).

To run the action, pytest-cov must be installed within cibuildwheel. Otherwise it runs into the following error.

Is there a way in the current scheme to detect only positive changes ?

Currently , am using window method.

def rupture_changepoint(points):
    points.values.reshape((points.shape[0],1))
    points = points.dropna()
    model = "l2"
    algo = rpt.Window(width = 10, model=model).fit(points.values)
    my_bkps = algo.predict(pen=60)
    print(my_bkps)
    fig, (ax,) = rpt.display(points, my_bkps, my_bkps, figsize=(10,6))
    plt.show()

Got the break points as [30, 40, 50, 100, 121]

Here, i dont want the decreasing trend to be there as a breakpoint. I am only interested in the [40,50] change.

Please point me to the specific files that needs to be changed if its not straightforward

Thank you,

I have a need for detecting change point of seismic waves, the onset seem quite obvious by visual inspection. But costAR and costL2 seem failed to detect the change point. Could you give me some suggestions about how to select a proper cost function among presented ones?

I am trying to add the ruptures code but unfortunately i couldn't get any result.

here is the code :

@app.callback( dash.dependencies.Output(component_id='chart_1', component_property="figure"), [dash.dependencies.Input('btn-nclicks-1', 'n_clicks')], [dash.dependencies.State('drop_down_1', 'value')], [dash.dependencies.State('drop_down_2', 'value')], [dash.dependencies.State('drop_down_3', 'value')], [dash.dependencies.State('drop_down_4', 'value')], prevent_initial_call=True ) def update_values_app1(_, regions, indicators, start_date, end_date): fig = go.Figure()

max_value_dict = dict()

if type(regions) == str:
    regions = [regions]

for region in regions:
    cd = global_df.loc[(global_df.loc[:, "country_region"] == region)]
    cd = cd.loc[((cd.loc[:, "date"] >= start_date) & (cd.loc[:, "date"] <= end_date))]
    x = cd["date"].values

    for iid, indicator in enumerate(indicators):
        y = cd[indicator].values
        notna_mask = ~np.isnan(y)

        if notna_mask.sum() == 0:
            max_value = 1
        else:
            max_value = max(abs(np.nanmax(y)), abs(np.nanmin(y)))

        if indicator not in max_value_dict:
            max_value_dict[indicator] = max_value
        else:
            max_value_dict[indicator] = max(max_value, max_value_dict[indicator])

        if iid == 0:
            fig = fig.add_trace(
                go.Scatter(x=x, y=y, mode='lines', name=region + " " + indicator,
                           line=dict(width=4)))
        else:
            fig = fig.add_trace(
                go.Scatter(x=x, y=y, mode='lines', name=region + " " + indicator, yaxis='y{}'.format(iid + 2),
                           line=dict(width=4)))

fig.update_layout(title="", xaxis_title="Date", yaxis_title="", legend_title="Indicators",
                  font=dict(family="Arial", size=20, color="dark blue"))

y_axis_label_width = 0.08

fig.update_layout(xaxis=dict(domain=[y_axis_label_width * (len(indicators) - 1), 1.0]))

for iid, indicator in enumerate(indicators):
    y_range = [-max_value_dict[indicator], max_value_dict[indicator]]
    if iid == 0:
        fig.update_layout({'yaxis': dict(title=indicator, constraintoward='center', position=0,
                                         range=y_range)})
    else:
        fig.update_layout({'yaxis{}'.format(iid + 2): dict(title=indicator, overlaying="y", side="left",
                                                           constraintoward='center', position=y_axis_label_width * iid,
                                                           range=y_range)})

fig.update_layout(legend=dict(font=dict(family="Arial", size=30, color="black")),
                  legend_title=dict(font=dict(family="Arial", size=35, color="blue")))
fig.update_layout(legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1))

fig.update_layout(margin=dict(t=250))
fig.update_layout(xaxis_tickangle=0)
fig.update_xaxes(showline=True, linewidth=2, linecolor='black')
fig.update_yaxes(showline=True, linewidth=2, linecolor='black')
fig.update_xaxes(zeroline=True, zerolinewidth=2, zerolinecolor='red')
fig.update_yaxes(zeroline=True, zerolinewidth=2, zerolinecolor='red')

return fig

Sylvain Arlot, Alain Celisse and Zaid Harchaoui provide theory and a heuristic for model selection with KernSeg in their paper A Kernel Multiple Change-point Algorithm via Model Selection. See 3.3.2, Theorem 2 and appendix B.3.

The penalty they propose does not scale linearly with the number of change points, so sadly it is incompatible with the current implementation. Furthermore the heuristic they propose requires knowledge of the respective losses for a set of possible numbers of split points, which currently (to my best understanding) cannot be recovered without expensive refits.

It would be great if this could be added.

On signals with truly constant segments, the CostNormal detection fails because the covariance matrix is badly conditioned, resulting in infinite value for the cost function. See #196.

import ruptures as rpt print(rpt.__version__)

1.1.7

lst_cp_det = list(np.sort(cp_detector.predict(n_bkps=n_cp))) ruptures\detection\dynp.py", line 132, in predict n_samples=self.cost.signal.shape[0], AttributeError: 'kernel_hyper' object has no attribute 'signal'

Hi!

I tried to use copy.deepcopy to copy Binseg object and met a problem: binseg.single_bkp and deepcopy(binseg).single_bkp referred to the same object. So, I can not use binseg_copy.single_bkp because it tries to use the data from the original object.

It seems to be caused by the way lru_cache is used. Are there any reasons not to use it with @ decorator syntax?

Repro case:

import ruptures as rpt import numpy as np

new_list = [-0.0155, 0.0194, 0.0289, 0.0071, -0.0059, -0.0102, 0.0046, 0.0218, 0.0153, 0.0491, 0.016, 0.0365, 0.0388, 0.0516, 0.0222, 0.0019, -0.0418, 0.0, -0.0262, 0.0468, 0.0, 0.0311, 0.0341, -0.0, 0.0569, 0.0206, 0.0336, 0.0615] trend_error = np.asarray(new_list)

results = set({}) for _ in range(10000): change_points = ( rpt.KernelCPD(kernel="rbf", min_size=7) .fit(trend_error) .predict(pen=1.0) ) results.add(len(change_points))

print(results)

When running this on a mac I'll get two different values in results : 2, 4 But when running this in a linux container it will consistently yield just 2

When running rpt.Pelt(model="rbf", jump=1, min_size=7) I repeatedly get a deterministic result (which matches the result in 2).

I have a few hundred 1-D timeseries, each ~120 points. Each timeseries may or may not have one or more breakpoints caused by changes in instrumentation, with the timing and nature of the instrumentation change differing from timeseries to timeseries and not known in advance for any of them. I am interested in estimating some measure of confidence for each timeseries that at least one breakpoint exists for that timeseries (in addition to when that breakpoint occurs).

What would you recommend using for this? This sounds to me like a statistical test based on BinSeg with n=1 breakpoints, but I'm new to breakpoints overall and to the ruptures package and so it's not obvious to me if that's correct conceptually nor how to do that with ruptures. Apologies if I'm moving too quickly and thus missing something clear in the docs.

updates:

• github.com/psf/black: 22.8.0 → 22.12.0
• github.com/pre-commit/pre-commit-hooks: v4.3.0 → v4.4.0
• github.com/PyCQA/docformatter: v1.5.0 → v1.5.1
• github.com/PyCQA/flake8: 5.0.4 → 6.0.0
• github.com/nbQA-dev/nbQA: 1.5.2 → 1.6.0

Hi !

Following the issue I opened about the possibility to add more metrics (#278), here is a PR to start working on the additional metrics.

For now I'm starting with the implementation of the adjusted Rand index based on scikit's implementation to have a first base to start with.

I also took care of adding scikit to the dependencies, I ran the tests and the installation works fine.

@deepcharles How do you want to proceed ? Do you already have a set of additional metrics in mind that could be added in addition to the adjusted Rand index and the Intersection over Union ?

Cheers,

Romain

Hi !

First of all thanks a lot for this great toolbox (and for the great review that comes with it).

While using ruptures I noticed that only a few metrics were available for comparing two segmentations and thought it would maybe be a good idea to implement additional ones.

For instance, it is super straightforward to implement the adjusted randindex by leveraging the efficient implementation of the adjusted rand score in scikit learn (although adding this to ruptures would imply to add scikit as a dependency) :

from sklearn.metrics import adjusted_rand_score


def chpt_to_label(bkps):
    """Return the segment index each sample belongs to.
    
    Example
    -------
    >>> chpt_to_label([4, 10])
    array([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
    """
    duration = np.diff([0] + bkps)
    return np.repeat(np.arange(len(bkps)), duration)


def randindex_adjusted(bkps1, bkps2):
    "Compute the adjusted rand index for two lists of changepoints."
    label1 = chpt_to_label(bkps1)
    label2 = chpt_to_label(bkps2)
    return adjusted_rand_score(label1, label2)

I guess there are much more similar metrics (Intersection over Union...) that could be added to ruptures in order to make the package even more complete than it is right now.

Of course this is simply a suggestion and I would be happy to give a hand if you think this direction would indeed be interesting to pursue :)

Cheers,

Romain

hello I am wondering if the ruptures library is working with multidimensional data or not ??

please look into the uploaded image: I used ruptures in my code, and it's showing the change point lines like what is shown . so if its working correctly with multidimensional data can you tell me how ??

regards

Super neat library! The API feels very well-designed 🤩

Reading the documentation, I miss a couple of things. Another (after #275) is grokking the cost functions. For me, plots work wonders, so I would love to be presented with a plot of a typical signal they would be useful on. For instance, I imagine that CostLinear is useful for something like this: I have no clue what the CostCLinear prototypical signal would look like, however 😄

Existing work

I see there's something in the Piecewise Gaussian generation page. It takes a little time to grok, but I got it now. I wish for something like this in the Cost function pages, too 🙏

Super neat library! The API feels very well-designed 🤩

Reading the documentation, I miss a couple of things. One of them is a central description about what pen is, and a general strategy for setting it or getting the right order of magnitude - or reasoning why no such strategy exists.

Perhaps something like (modified from #271)

The penalty value is a positive float that controls how many changes you want (higher values yield fewer changepoints). Finding a correct value is really dependent on your situation, but as a rule of thumb pen can be initialized to around [rule of thumb] and tweaked up and down from there.

Existing work

In Binseg and sibling models there's this magic incantation:

my_bkps = algo.predict(pen=np.log(n) * dim * sigma**2)

Was it produced with some rule of thumb? In the advanced usage, kernel article, it is set twice to values 2 OOM apart:

penalty_value = 100  # beta
penalty_value = 1  # beta

The suggestion in #271 for reading an article is fine; what I lack is a paragraph or two somewhere visible. The penalty term seems important enough to be worth it.