def hurst_exponent(x: np.array) -> float:
"""Computes hurst exponent.
Parameters
----------
x: numpy array
Time series.
References
----------
[1] Taken from https://gist.github.com/alexvorndran/aad69fa741e579aad093608ccaab4fe1
[2] Based on https://codereview.stackexchange.com/questions/224360/hurst-exponent-calculator
"""
n = x.size # num timesteps
t = np.arange(1, n + 1)
y = x.cumsum() # marginally more efficient than: np.cumsum(sig)
mean_t = y / t # running mean
s_t = np.sqrt(
np.array([np.mean((x[:i + 1] - mean_t[i])**2) for i in range(n)]))
r_t = np.array(
[np.ptp(y[:i + 1] - t[:i + 1] * mean_t[i]) for i in range(n)])
with np.errstate(invalid='ignore'):
r_s = r_t / s_t
r_s = np.log(r_s)[1:]
n = np.log(t)[1:]
a = np.column_stack((n, np.ones(n.size)))
hurst_exponent, _ = np.linalg.lstsq(a, r_s, rcond=-1)[0]
return hurst_exponent
def _downsample_array(
col: np.array,
target: int,
random_state: Optional[Union[int, RandomState]] = 0,
replace: bool = True,
inplace: bool = False,
):
"""\
Evenly reduce counts in cell to target amount.
This is an internal function and has some restrictions:
* `dtype` of col must be an integer (i.e. satisfy issubclass(col.dtype.type, np.integer))
* total counts in cell must be less than target
"""
np.random.seed(random_state)
cumcounts = col.cumsum()
if inplace:
col[:] = 0
else:
col = np.zeros_like(col)
total = cumcounts[-1]
sample = np.random.choice(total, target, replace=replace)
sample.sort()
geneptr = 0
for count in sample:
while count >= cumcounts[geneptr]:
geneptr += 1
col[geneptr] += 1
return col
def _instance_iou_cpu(
instance_idx,
instance_offsets,
gt_instances,
gt_instance_sizes,
num_gt_instances: np.array,
batch: np.array,
):
num_proposed_instances = len(instance_offsets) - 1
iou = np.zeros((num_proposed_instances, num_gt_instances.sum()))
offset_num_gt_instances = np.concatenate(
(np.array([0]), num_gt_instances.cumsum()))
for proposed_instance in range(num_proposed_instances):
instance = instance_idx[instance_offsets[proposed_instance]:
instance_offsets[proposed_instance + 1]]
sample_idx = batch[instance[0]]
gt_count_offset = offset_num_gt_instances[sample_idx]
sample_instance_count = num_gt_instances[sample_idx]
for instance_id in numba.prange(1, sample_instance_count + 1):
intersection = 0
for idx in instance:
if gt_instances[idx] == instance_id:
intersection += 1
iou[proposed_instance,
gt_count_offset + instance_id - 1] = intersection / float(
len(instance) +
gt_instance_sizes[gt_count_offset + instance_id - 1] -
intersection)
return iou
def draw_cleanup(draws: np.array, x: np.array,
df: pd.DataFrame) -> pd.DataFrame:
# set to linear, add up cumulative, and create dataframe
draws -= np.var(draws, axis=1, keepdims=True) / 2
draws = np.exp(draws)
draws[draws * df['population'].values[0] <
1e-10] = 1e-10 / df['population'].values[0]
draws = draws.cumsum(axis=0)
# store in dataframe
draw_df = pd.DataFrame({
'location_id':
df['location_id'].unique().item(),
'Date': [df['Date'].min() + pd.Timedelta(days=dx) for dx in x],
'population':
df['population'].unique().item()
})
draw_df = pd.concat([
draw_df,
pd.DataFrame(draws,
columns=[f'draw_{d}' for d in range(draws.shape[1])])
],
axis=1)
return draw_df
def errors(ws: array, e_share=0.0) -> array:
"""
Returns a stake-weighted population of adverserial members,
with `e_share` being the *percentage* of the total weights.
"""
return ws.cumsum() < e_share
