From 807b4058f6b7e66767a9f1474585720bfa032092 Mon Sep 17 00:00:00 2001 From: bskrlj Date: Thu, 28 Sep 2023 14:51:26 +0200 Subject: [PATCH] Docs and version --- .../feature_ranking/ranking_mi_numba.html | 456 +-- docs/outrank/core_ranking.html | 2618 ++++++++--------- docs/outrank/task_selftest.html | 4 +- docs/search.js | 2 +- setup.py | 2 +- 5 files changed, 1525 insertions(+), 1557 deletions(-) diff --git a/docs/outrank/algorithms/feature_ranking/ranking_mi_numba.html b/docs/outrank/algorithms/feature_ranking/ranking_mi_numba.html index 89c8bc5..4045afa 100644 --- a/docs/outrank/algorithms/feature_ranking/ranking_mi_numba.html +++ b/docs/outrank/algorithms/feature_ranking/ranking_mi_numba.html @@ -94,158 +94,166 @@

29 30 31@njit( - 32 'float32(int32[:], int32[:], int32, float32)', + 32 'float32(int32[:], int32[:], int32, float32, int32[:])', 33 cache=True, 34 fastmath=True, 35 error_model='numpy', 36 boundscheck=True, 37) - 38def compute_conditional_entropy(Y_classes, class_values, class_var_shape, initial_prob): + 38def compute_conditional_entropy(Y_classes, class_values, class_var_shape, initial_prob, nonzero_counts): 39 conditional_entropy = 0.0 - 40 + 40 index = 0 41 for c in class_values: - 42 conditional_prob = np.count_nonzero(Y_classes == c) / class_var_shape + 42 conditional_prob = nonzero_counts[index] / class_var_shape 43 if conditional_prob != 0: 44 conditional_entropy -= ( 45 initial_prob * conditional_prob * np.log(conditional_prob) 46 ) - 47 - 48 return conditional_entropy - 49 + 47 index += 1 + 48 + 49 return conditional_entropy 50 - 51@njit( - 52 'float32(int32[:], int32[:], int32, int32[:], int32[:], b1)', - 53 cache=True, - 54 parallel=False, - 55 fastmath=True, - 56 error_model='numpy', - 57 boundscheck=True, - 58) - 59def compute_entropies( - 60 X, Y, all_events, f_values, f_value_counts, cardinality_correction, - 61): - 62 """Core entropy computation function""" - 63 - 64 conditional_entropy = 0.0 - 65 background_cond_entropy = 0.0 - 66 full_entropy = 0.0 - 67 - 68 class_values, class_counts = numba_unique(Y) - 69 - 70 if not cardinality_correction: - 71 for k in prange(len(class_counts)): - 72 class_probability = class_counts[k] / all_events - 73 full_entropy += -class_probability * np.log(class_probability) - 74 - 75 for f_index in prange(len(f_values)): - 76 _f_value_counts = f_value_counts[f_index] - 77 - 78 if _f_value_counts == 1: - 79 continue - 80 - 81 initial_prob = _f_value_counts / all_events - 82 x_value_subspace = np.where(X == f_values[f_index]) - 83 Y_classes = Y[x_value_subspace] - 84 conditional_entropy += compute_conditional_entropy( - 85 Y_classes, class_values, _f_value_counts, initial_prob, - 86 ) + 51 + 52@njit( + 53 'float32(int32[:], int32[:], int32, int32[:], int32[:], b1)', + 54 cache=True, + 55 parallel=False, + 56 fastmath=True, + 57 error_model='numpy', + 58 boundscheck=True, + 59) + 60def compute_entropies( + 61 X, Y, all_events, f_values, f_value_counts, cardinality_correction, + 62): + 63 """Core entropy computation function""" + 64 + 65 conditional_entropy = 0.0 + 66 background_cond_entropy = 0.0 + 67 full_entropy = 0.0 + 68 + 69 class_values, class_counts = numba_unique(Y) + 70 + 71 if not cardinality_correction: + 72 for k in prange(len(class_counts)): + 73 class_probability = class_counts[k] / all_events + 74 full_entropy += -class_probability * np.log(class_probability) + 75 + 76 for f_index in prange(len(f_values)): + 77 _f_value_counts = f_value_counts[f_index] + 78 + 79 if _f_value_counts == 1: + 80 continue + 81 + 82 initial_prob = _f_value_counts / all_events + 83 x_value_subspace = np.where(X == f_values[f_index]) + 84 Y_classes = Y[x_value_subspace] + 85 index = 0 + 86 nonzero_class_counts = np.zeros(len(class_values), dtype=np.int32) 87 - 88 if cardinality_correction: - 89 # A neat hack that seems to work fine (permutations are expensive) - 90 Y_classes = np.roll(Y, _f_value_counts)[x_value_subspace] - 91 - 92 background_cond_entropy += compute_conditional_entropy( - 93 Y_classes, class_values, _f_value_counts, initial_prob, - 94 ) + 88 # Cache nonzero counts + 89 for c in class_values: + 90 nonzero_class_counts[index] = np.count_nonzero(Y_classes == c) + 91 index += 1 + 92 conditional_entropy += compute_conditional_entropy( + 93 Y_classes, class_values, _f_value_counts, initial_prob, nonzero_class_counts, + 94 ) 95 - 96 if not cardinality_correction: - 97 return full_entropy - conditional_entropy - 98 - 99 else: -100 # note: full entropy falls out during derivation of final term -101 core_joint_entropy = -conditional_entropy + background_cond_entropy -102 return core_joint_entropy + 96 if cardinality_correction: + 97 # A neat hack that seems to work fine (permutations are expensive) + 98 Y_classes = np.roll(Y, _f_value_counts)[x_value_subspace] + 99 +100 background_cond_entropy += compute_conditional_entropy( +101 Y_classes, class_values, _f_value_counts, initial_prob, nonzero_class_counts, +102 ) 103 -104 -105@njit( -106 'float32(int32[:], int32[:], float32, b1)', -107 cache=True, -108 fastmath=True, -109 error_model='numpy', -110 boundscheck=True, -111) -112def mutual_info_estimator_numba( -113 Y, X, approximation_factor=1, cardinality_correction=False, -114): -115 """Core estimator logic. Compute unique elements, subset if required""" -116 -117 all_events = len(X) -118 f_values, f_value_counts = numba_unique(X) -119 -120 # Diagonal entries -121 if np.sum(X - Y) == 0: -122 cardinality_correction = False -123 -124 if approximation_factor < 1: -125 subspace_size = int(approximation_factor * all_events) -126 if subspace_size != 0: -127 subspace = np.random.randint(0, all_events, size=subspace_size) -128 X = X[subspace] -129 Y = Y[subspace] -130 -131 joint_entropy_core = compute_entropies( -132 X, Y, all_events, f_values, f_value_counts, cardinality_correction, -133 ) -134 -135 return approximation_factor * joint_entropy_core -136 -137 -138if __name__ == '__main__': -139 import pandas as pd -140 from sklearn.feature_selection import mutual_info_classif -141 -142 np.random.seed(123) -143 import time +104 if not cardinality_correction: +105 return full_entropy - conditional_entropy +106 +107 else: +108 # note: full entropy falls out during derivation of final term +109 core_joint_entropy = -conditional_entropy + background_cond_entropy +110 return core_joint_entropy +111 +112 +113@njit( +114 'float32(int32[:], int32[:], float32, b1)', +115 cache=True, +116 fastmath=True, +117 error_model='numpy', +118 boundscheck=True, +119) +120def mutual_info_estimator_numba( +121 Y, X, approximation_factor=1, cardinality_correction=False, +122): +123 """Core estimator logic. Compute unique elements, subset if required""" +124 +125 all_events = len(X) +126 f_values, f_value_counts = numba_unique(X) +127 +128 # Diagonal entries +129 if np.sum(X - Y) == 0: +130 cardinality_correction = False +131 +132 if approximation_factor < 1: +133 subspace_size = int(approximation_factor * all_events) +134 if subspace_size != 0: +135 subspace = np.random.randint(0, all_events, size=subspace_size) +136 X = X[subspace] +137 Y = Y[subspace] +138 +139 joint_entropy_core = compute_entropies( +140 X, Y, all_events, f_values, f_value_counts, cardinality_correction, +141 ) +142 +143 return approximation_factor * joint_entropy_core 144 -145 final_times = [] -146 for algo in ['MI-numba-randomized']: -147 for order in range(20, 21): -148 for j in range(1): -149 start = time.time() -150 a = np.random.randint(1000, size=2**order).astype(np.int32) -151 b = np.random.randint(1000, size=2**order).astype(np.int32) -152 if algo == 'MI': -153 final_score = mutual_info_classif( -154 a.reshape(-1, 1), b.reshape(-1), discrete_features=True, -155 ) -156 elif algo == 'MI-numba-randomized': -157 final_score = mutual_info_estimator_numba( -158 a, b, np.float32(1.0), True, -159 ) -160 elif algo == 'MI-numba': -161 final_score = mutual_info_estimator_numba( -162 a, b, np.float32(1.0), False, +145 +146if __name__ == '__main__': +147 import pandas as pd +148 from sklearn.feature_selection import mutual_info_classif +149 +150 np.random.seed(123) +151 import time +152 +153 final_times = [] +154 for algo in ['MI-numba-randomized']: +155 for order in range(20, 21): +156 for j in range(1): +157 start = time.time() +158 a = np.random.randint(1000, size=2**order).astype(np.int32) +159 b = np.random.randint(1000, size=2**order).astype(np.int32) +160 if algo == 'MI': +161 final_score = mutual_info_classif( +162 a.reshape(-1, 1), b.reshape(-1), discrete_features=True, 163 ) -164 elif algo == 'MI-numba-randomized-ap': +164 elif algo == 'MI-numba-randomized': 165 final_score = mutual_info_estimator_numba( -166 a, b, np.float32(0.3), True, +166 a, b, np.float32(1.0), True, 167 ) -168 elif algo == 'MI-numba-ap': +168 elif algo == 'MI-numba': 169 final_score = mutual_info_estimator_numba( -170 a, b, np.float32(0.3), False, +170 a, b, np.float32(1.0), False, 171 ) -172 -173 end = time.time() -174 tdiff = end - start -175 instance = { -176 'time': tdiff, -177 'samples 2e': order, 'algorithm': algo, -178 } -179 final_times.append(instance) -180 print(instance) -181 dfx = pd.DataFrame(final_times) -182 dfx = dfx.sort_values(by=['samples 2e']) -183 print(dfx) +172 elif algo == 'MI-numba-randomized-ap': +173 final_score = mutual_info_estimator_numba( +174 a, b, np.float32(0.3), True, +175 ) +176 elif algo == 'MI-numba-ap': +177 final_score = mutual_info_estimator_numba( +178 a, b, np.float32(0.3), False, +179 ) +180 +181 end = time.time() +182 tdiff = end - start +183 instance = { +184 'time': tdiff, +185 'samples 2e': order, 'algorithm': algo, +186 } +187 final_times.append(instance) +188 print(instance) +189 dfx = pd.DataFrame(final_times) +190 dfx = dfx.sort_values(by=['samples 2e']) +191 print(dfx) @@ -291,33 +299,34 @@

-
@njit('float32(int32[:], int32[:], int32, float32)', cache=True, fastmath=True, error_model='numpy', boundscheck=True)
+
@njit('float32(int32[:], int32[:], int32, float32, int32[:])', cache=True, fastmath=True, error_model='numpy', boundscheck=True)
def - compute_conditional_entropy(Y_classes, class_values, class_var_shape, initial_prob): + compute_conditional_entropy( Y_classes, class_values, class_var_shape, initial_prob, nonzero_counts): 
32@njit(
-33    'float32(int32[:], int32[:], int32, float32)',
+33    'float32(int32[:], int32[:], int32, float32, int32[:])',
 34    cache=True,
 35    fastmath=True,
 36    error_model='numpy',
 37    boundscheck=True,
 38)
-39def compute_conditional_entropy(Y_classes, class_values, class_var_shape, initial_prob):
+39def compute_conditional_entropy(Y_classes, class_values, class_var_shape, initial_prob, nonzero_counts):
 40    conditional_entropy = 0.0
-41
+41    index = 0
 42    for c in class_values:
-43        conditional_prob = np.count_nonzero(Y_classes == c) / class_var_shape
+43        conditional_prob = nonzero_counts[index] / class_var_shape
 44        if conditional_prob != 0:
 45            conditional_entropy -= (
 46                initial_prob * conditional_prob * np.log(conditional_prob)
 47            )
-48
-49    return conditional_entropy
+48        index += 1
+49
+50    return conditional_entropy
@@ -336,58 +345,65 @@

- 
 52@njit(
- 53    'float32(int32[:], int32[:], int32, int32[:], int32[:], b1)',
- 54    cache=True,
- 55    parallel=False,
- 56    fastmath=True,
- 57    error_model='numpy',
- 58    boundscheck=True,
- 59)
- 60def compute_entropies(
- 61    X, Y, all_events, f_values, f_value_counts, cardinality_correction,
- 62):
- 63    """Core entropy computation function"""
- 64
- 65    conditional_entropy = 0.0
- 66    background_cond_entropy = 0.0
- 67    full_entropy = 0.0
- 68
- 69    class_values, class_counts = numba_unique(Y)
- 70
- 71    if not cardinality_correction:
- 72        for k in prange(len(class_counts)):
- 73            class_probability = class_counts[k] / all_events
- 74            full_entropy += -class_probability * np.log(class_probability)
- 75
- 76    for f_index in prange(len(f_values)):
- 77        _f_value_counts = f_value_counts[f_index]
- 78
- 79        if _f_value_counts == 1:
- 80            continue
- 81
- 82        initial_prob = _f_value_counts / all_events
- 83        x_value_subspace = np.where(X == f_values[f_index])
- 84        Y_classes = Y[x_value_subspace]
- 85        conditional_entropy += compute_conditional_entropy(
- 86            Y_classes, class_values, _f_value_counts, initial_prob,
- 87        )
+            
 53@njit(
+ 54    'float32(int32[:], int32[:], int32, int32[:], int32[:], b1)',
+ 55    cache=True,
+ 56    parallel=False,
+ 57    fastmath=True,
+ 58    error_model='numpy',
+ 59    boundscheck=True,
+ 60)
+ 61def compute_entropies(
+ 62    X, Y, all_events, f_values, f_value_counts, cardinality_correction,
+ 63):
+ 64    """Core entropy computation function"""
+ 65
+ 66    conditional_entropy = 0.0
+ 67    background_cond_entropy = 0.0
+ 68    full_entropy = 0.0
+ 69
+ 70    class_values, class_counts = numba_unique(Y)
+ 71
+ 72    if not cardinality_correction:
+ 73        for k in prange(len(class_counts)):
+ 74            class_probability = class_counts[k] / all_events
+ 75            full_entropy += -class_probability * np.log(class_probability)
+ 76
+ 77    for f_index in prange(len(f_values)):
+ 78        _f_value_counts = f_value_counts[f_index]
+ 79
+ 80        if _f_value_counts == 1:
+ 81            continue
+ 82
+ 83        initial_prob = _f_value_counts / all_events
+ 84        x_value_subspace = np.where(X == f_values[f_index])
+ 85        Y_classes = Y[x_value_subspace]
+ 86        index = 0
+ 87        nonzero_class_counts = np.zeros(len(class_values), dtype=np.int32)
  88
- 89        if cardinality_correction:
- 90            # A neat hack that seems to work fine (permutations are expensive)
- 91            Y_classes = np.roll(Y, _f_value_counts)[x_value_subspace]
- 92
- 93            background_cond_entropy += compute_conditional_entropy(
- 94                Y_classes, class_values, _f_value_counts, initial_prob,
- 95            )
+ 89        # Cache nonzero counts
+ 90        for c in class_values:
+ 91            nonzero_class_counts[index] = np.count_nonzero(Y_classes == c)
+ 92            index += 1
+ 93        conditional_entropy += compute_conditional_entropy(
+ 94            Y_classes, class_values, _f_value_counts, initial_prob, nonzero_class_counts,
+ 95        )
  96
- 97    if not cardinality_correction:
- 98        return full_entropy - conditional_entropy
- 99
-100    else:
-101        # note: full entropy falls out during derivation of final term
-102        core_joint_entropy = -conditional_entropy + background_cond_entropy
-103        return core_joint_entropy
+ 97        if cardinality_correction:
+ 98            # A neat hack that seems to work fine (permutations are expensive)
+ 99            Y_classes = np.roll(Y, _f_value_counts)[x_value_subspace]
+100
+101            background_cond_entropy += compute_conditional_entropy(
+102                Y_classes, class_values, _f_value_counts, initial_prob, nonzero_class_counts,
+103            )
+104
+105    if not cardinality_correction:
+106        return full_entropy - conditional_entropy
+107
+108    else:
+109        # note: full entropy falls out during derivation of final term
+110        core_joint_entropy = -conditional_entropy + background_cond_entropy
+111        return core_joint_entropy
 

 
 
@@ -408,37 +424,37 @@
- 
106@njit(
-107    'float32(int32[:], int32[:], float32, b1)',
-108    cache=True,
-109    fastmath=True,
-110    error_model='numpy',
-111    boundscheck=True,
-112)
-113def mutual_info_estimator_numba(
-114    Y, X, approximation_factor=1, cardinality_correction=False,
-115):
-116    """Core estimator logic. Compute unique elements, subset if required"""
-117
-118    all_events = len(X)
-119    f_values, f_value_counts = numba_unique(X)
-120
-121    # Diagonal entries
-122    if np.sum(X - Y) == 0:
-123        cardinality_correction = False
-124
-125    if approximation_factor < 1:
-126        subspace_size = int(approximation_factor * all_events)
-127        if subspace_size != 0:
-128            subspace = np.random.randint(0, all_events, size=subspace_size)
-129            X = X[subspace]
-130            Y = Y[subspace]
-131
-132    joint_entropy_core = compute_entropies(
-133        X, Y, all_events, f_values, f_value_counts, cardinality_correction,
-134    )
-135
-136    return approximation_factor * joint_entropy_core
+            
114@njit(
+115    'float32(int32[:], int32[:], float32, b1)',
+116    cache=True,
+117    fastmath=True,
+118    error_model='numpy',
+119    boundscheck=True,
+120)
+121def mutual_info_estimator_numba(
+122    Y, X, approximation_factor=1, cardinality_correction=False,
+123):
+124    """Core estimator logic. Compute unique elements, subset if required"""
+125
+126    all_events = len(X)
+127    f_values, f_value_counts = numba_unique(X)
+128
+129    # Diagonal entries
+130    if np.sum(X - Y) == 0:
+131        cardinality_correction = False
+132
+133    if approximation_factor < 1:
+134        subspace_size = int(approximation_factor * all_events)
+135        if subspace_size != 0:
+136            subspace = np.random.randint(0, all_events, size=subspace_size)
+137            X = X[subspace]
+138            Y = Y[subspace]
+139
+140    joint_entropy_core = compute_entropies(
+141        X, Y, all_events, f_values, f_value_counts, cardinality_correction,
+142    )
+143
+144    return approximation_factor * joint_entropy_core
 

 
 
diff --git a/docs/outrank/core_ranking.html b/docs/outrank/core_ranking.html
index 230891d..5d31692 100644
--- a/docs/outrank/core_ranking.html
+++ b/docs/outrank/core_ranking.html
@@ -45,9 +45,6 @@ 
API Documentation

             
  • 
                     HYPERLL_ERROR_BOUND
             
    • 
-            
  • 
-                    encode_int_column
-            
    • 
             
  • 
                     mixed_rank_graph
             
    • 
@@ -163,692 +160,678 @@ 
    
  44HYPERLL_ERROR_BOUND = 0.02
  45
  46
- 47def encode_int_column(input_tuple: tuple[str, Any]) -> tuple[Any, list[int]]:
- 48    """Encode column values as categoric (at a batch level!)"""
- 49
- 50    hashes, _ = pd.factorize(input_tuple[1])
- 51    return input_tuple[0], hashes
- 52
+ 47def mixed_rank_graph(
+ 48    input_dataframe: pd.DataFrame, args: Any, cpu_pool: Any, pbar: Any,
+ 49) -> BatchRankingSummary:
+ 50    """Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic"""
+ 51
+ 52    all_columns = input_dataframe.columns
  53
- 54def mixed_rank_graph(
- 55    input_dataframe: pd.DataFrame, args: Any, cpu_pool: Any, pbar: Any,
- 56) -> BatchRankingSummary:
- 57    """Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic"""
- 58
- 59    all_columns = input_dataframe.columns
- 60
- 61    triplets = []
- 62    tmp_df = input_dataframe.copy()
- 63    out_time_struct = {}
- 64
- 65    # Handle cont. types prior to interaction evaluation
- 66    pbar.set_description('Encoding columns')
- 67    jobs = [(cname, tmp_df[cname]) for cname in all_columns]
- 68    col_dots = '.'
- 69    start_enc_timer = timer()
- 70    with cpu_pool as p:
- 71        results = p.amap(encode_int_column, jobs)
- 72        while not results.ready():
- 73            time.sleep(4)
- 74            col_dots = col_dots + '.'
- 75            pbar.set_description(f'Encoding columns .{col_dots}')
- 76        tmp_df = pd.DataFrame({k: v for k, v in results.get()})
- 77    end_enc_timer = timer()
- 78    out_time_struct['encoding_columns'] = end_enc_timer - start_enc_timer
- 79
- 80    # Helper method for parallel estimation
- 81    combinations = list(
- 82        itertools.combinations_with_replacement(all_columns, 2),
- 83    )
+ 54    triplets = []
+ 55    tmp_df = input_dataframe.copy().astype('category')
+ 56    out_time_struct = {}
+ 57
+ 58    # Handle cont. types prior to interaction evaluation
+ 59    pbar.set_description('Encoding columns')
+ 60    col_dots = '.'
+ 61    start_enc_timer = timer()
+ 62    tmp_df = pd.DataFrame({k : tmp_df[k].cat.codes for k in all_columns})
+ 63    end_enc_timer = timer()
+ 64    out_time_struct['encoding_columns'] = end_enc_timer - start_enc_timer
+ 65
+ 66    # Helper method for parallel estimation
+ 67    combinations = list(
+ 68        itertools.combinations_with_replacement(all_columns, 2),
+ 69    )
+ 70
+ 71    if '3mr' in args.heuristic:
+ 72        rel_columns = [
+ 73            column for column in all_columns if ' AND_REL ' in column
+ 74        ]
+ 75        non_rel_columns = list(set(all_columns) - set(rel_columns))
+ 76        combinations = list(
+ 77            itertools.combinations_with_replacement(non_rel_columns, 2),
+ 78        )
+ 79        combinations += [(column, args.label_column) for column in rel_columns]
+ 80    else:
+ 81        combinations = list(
+ 82            itertools.combinations_with_replacement(all_columns, 2),
+ 83        )
  84
- 85    if '3mr' in args.heuristic:
- 86        rel_columns = [
- 87            column for column in all_columns if ' AND_REL ' in column
- 88        ]
- 89        non_rel_columns = list(set(all_columns) - set(rel_columns))
- 90        combinations = list(
- 91            itertools.combinations_with_replacement(non_rel_columns, 2),
- 92        )
- 93        combinations += [(column, args.label_column) for column in rel_columns]
- 94    else:
- 95        combinations = list(
- 96            itertools.combinations_with_replacement(all_columns, 2),
- 97        )
- 98
- 99    # Diagonal elements
-100    for individual_column in all_columns:
-101        if individual_column != args.label_column:
-102            combinations += [(individual_column, individual_column)]
-103
-104    # Some applications do not require the full feature-feature triangular matrix
-105    if (args.target_ranking_only == 'True') and ('3mr' not in args.heuristic):
-106        combinations = [x for x in combinations if args.label_column in x]
-107
-108    random.shuffle(combinations)
-109    combinations = combinations[: args.combination_number_upper_bound]
-110
-111    if args.heuristic == 'Constant':
-112        final_constant_imp = []
-113        for c1, c2 in combinations:
-114            final_constant_imp.append((c1, c2, 0.0))
-115
-116        out_time_struct['feature_score_computation'] = end_enc_timer - \
-117            start_enc_timer
-118        return BatchRankingSummary(final_constant_imp, out_time_struct)
-119
-120    # Map the scoring calls to the worker pool
-121    pbar.set_description('Allocating thread pool')
-122
-123    # starmap is an alternative that is slower unfortunately (but nicer)
-124    def get_grounded_importances_estimate(combination: tuple[str]) -> Any:
-125        return get_importances_estimate_pairwise(combination, args, tmp_df=tmp_df)
-126
-127    start_enc_timer = timer()
-128    with cpu_pool as p:
-129        pbar.set_description(f'Computing (#ftr={len(combinations)})')
-130        results = p.amap(get_grounded_importances_estimate, combinations)
-131        while not results.ready():
-132            time.sleep(4)
-133        triplets = results.get()
-134    end_enc_timer = timer()
-135    out_time_struct['feature_score_computation'] = end_enc_timer - \
-136        start_enc_timer
-137
-138    # Gather the final triplets
-139    pbar.set_description('Aggregation of ranking results')
-140    final_triplets = []
-141    for triplet in triplets:
-142        inv = (triplet[1], triplet[0], triplet[2])
-143        final_triplets.append(inv)
-144        final_triplets.append(triplet)
-145        triplets = final_triplets
-146
-147    pbar.set_description('Proceeding to the next batch of data')
-148    return BatchRankingSummary(triplets, out_time_struct)
+ 85    # Diagonal elements
+ 86    for individual_column in all_columns:
+ 87        if individual_column != args.label_column:
+ 88            combinations += [(individual_column, individual_column)]
+ 89
+ 90    # Some applications do not require the full feature-feature triangular matrix
+ 91    if (args.target_ranking_only == 'True') and ('3mr' not in args.heuristic):
+ 92        combinations = [x for x in combinations if args.label_column in x]
+ 93
+ 94    random.shuffle(combinations)
+ 95    combinations = combinations[: args.combination_number_upper_bound]
+ 96
+ 97    if args.heuristic == 'Constant':
+ 98        final_constant_imp = []
+ 99        for c1, c2 in combinations:
+100            final_constant_imp.append((c1, c2, 0.0))
+101
+102        out_time_struct['feature_score_computation'] = end_enc_timer - \
+103            start_enc_timer
+104        return BatchRankingSummary(final_constant_imp, out_time_struct)
+105
+106    # Map the scoring calls to the worker pool
+107    pbar.set_description('Allocating thread pool')
+108
+109    # starmap is an alternative that is slower unfortunately (but nicer)
+110    def get_grounded_importances_estimate(combination: tuple[str]) -> Any:
+111        return get_importances_estimate_pairwise(combination, args, tmp_df=tmp_df)
+112
+113    start_enc_timer = timer()
+114    with cpu_pool as p:
+115        pbar.set_description(f'Computing (#ftr={len(combinations)})')
+116        results = p.amap(get_grounded_importances_estimate, combinations)
+117        while not results.ready():
+118            time.sleep(4)
+119        triplets = results.get()
+120    end_enc_timer = timer()
+121    out_time_struct['feature_score_computation'] = end_enc_timer - \
+122        start_enc_timer
+123
+124    # Gather the final triplets
+125    pbar.set_description('Aggregation of ranking results')
+126    final_triplets = []
+127    for triplet in triplets:
+128        inv = (triplet[1], triplet[0], triplet[2])
+129        final_triplets.append(inv)
+130        final_triplets.append(triplet)
+131        triplets = final_triplets
+132
+133    pbar.set_description('Proceeding to the next batch of data')
+134    return BatchRankingSummary(triplets, out_time_struct)
+135
+136
+137def enrich_with_transformations(
+138    input_dataframe: pd.DataFrame, num_col_types: set[str], logger: Any, args: Any,
+139) -> pd.DataFrame:
+140    """Construct a collection of new features based on pre-defined transformations/rules"""
+141
+142    transformer = FeatureTransformerGeneric(
+143        num_col_types, preset=args.transformers,
+144    )
+145    transformed_df = transformer.construct_new_features(input_dataframe)
+146    logger.info(
+147        f'Constructed {len(transformer.constructed_feature_names)} new features ..',
+148    )
 149
-150
-151def enrich_with_transformations(
-152    input_dataframe: pd.DataFrame, num_col_types: set[str], logger: Any, args: Any,
-153) -> pd.DataFrame:
-154    """Construct a collection of new features based on pre-defined transformations/rules"""
-155
-156    transformer = FeatureTransformerGeneric(
-157        num_col_types, preset=args.transformers,
-158    )
-159    transformed_df = transformer.construct_new_features(input_dataframe)
-160    logger.info(
-161        f'Constructed {len(transformer.constructed_feature_names)} new features ..',
-162    )
-163
-164    return transformed_df
-165
-166
-167def compute_combined_features(
-168    input_dataframe: pd.DataFrame,
-169    logger: Any,
-170    args: Any,
-171    pbar: Any,
-172    is_3mr: bool = False,
-173) -> pd.DataFrame:
-174    """Compute higher order features via xxhash-based trick."""
-175
-176    all_columns = [
-177        x for x in input_dataframe.columns if x != args.label_column
-178    ]
-179    join_string = ' AND_REL ' if is_3mr else ' AND '
-180    interaction_order = 2 if is_3mr else args.interaction_order
-181
-182    full_combination_space = list(
-183        itertools.combinations(all_columns, interaction_order),
-184    )
-185
-186    if args.combination_number_upper_bound:
-187        random.shuffle(full_combination_space)
-188        full_combination_space = full_combination_space[
-189            : args.combination_number_upper_bound
-190        ]
-191
-192    com_counter = 0
-193    new_feature_hash = {}
-194    for new_combination in full_combination_space:
-195        pbar.set_description(
-196            f'Created {com_counter}/{len(full_combination_space)}',
-197        )
-198        combined_feature: list[str] = [str(0)] * input_dataframe.shape[0]
-199        for feature in new_combination:
-200            tmp_feature = input_dataframe[feature].tolist()
-201            for enx, el in enumerate(tmp_feature):
-202                combined_feature[enx] = str(
-203                    internal_hash(
-204                        str(combined_feature[enx]) + str(el),
-205                    ),
-206                )
-207        ftr_name = join_string.join(str(x) for x in new_combination)
-208        new_feature_hash[ftr_name] = combined_feature
-209        com_counter += 1
-210    tmp_df = pd.DataFrame(new_feature_hash)
-211    pbar.set_description('Concatenating into final frame ..')
-212    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
-213    del tmp_df
+150    return transformed_df
+151
+152
+153def compute_combined_features(
+154    input_dataframe: pd.DataFrame,
+155    logger: Any,
+156    args: Any,
+157    pbar: Any,
+158    is_3mr: bool = False,
+159) -> pd.DataFrame:
+160    """Compute higher order features via xxhash-based trick."""
+161
+162    all_columns = [
+163        x for x in input_dataframe.columns if x != args.label_column
+164    ]
+165    join_string = ' AND_REL ' if is_3mr else ' AND '
+166    interaction_order = 2 if is_3mr else args.interaction_order
+167
+168    full_combination_space = list(
+169        itertools.combinations(all_columns, interaction_order),
+170    )
+171
+172    if args.combination_number_upper_bound:
+173        random.shuffle(full_combination_space)
+174        full_combination_space = full_combination_space[
+175            : args.combination_number_upper_bound
+176        ]
+177
+178    com_counter = 0
+179    new_feature_hash = {}
+180    for new_combination in full_combination_space:
+181        pbar.set_description(
+182            f'Created {com_counter}/{len(full_combination_space)}',
+183        )
+184        combined_feature: list[str] = [str(0)] * input_dataframe.shape[0]
+185        for feature in new_combination:
+186            tmp_feature = input_dataframe[feature].tolist()
+187            for enx, el in enumerate(tmp_feature):
+188                combined_feature[enx] = str(
+189                    internal_hash(
+190                        str(combined_feature[enx]) + str(el),
+191                    ),
+192                )
+193        ftr_name = join_string.join(str(x) for x in new_combination)
+194        new_feature_hash[ftr_name] = combined_feature
+195        com_counter += 1
+196    tmp_df = pd.DataFrame(new_feature_hash)
+197    pbar.set_description('Concatenating into final frame ..')
+198    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+199    del tmp_df
+200
+201    return input_dataframe
+202
+203
+204def compute_expanded_multivalue_features(
+205    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
+206) -> pd.DataFrame:
+207    """Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value "a,b,c" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice."""
+208
+209    considered_multivalue_features = args.explode_multivalue_features.split(
+210        ';',
+211    )
+212    new_feature_hash = {}
+213    missing_symbols = set(args.missing_value_symbols.split(','))
 214
-215    return input_dataframe
-216
-217
-218def compute_expanded_multivalue_features(
-219    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
-220) -> pd.DataFrame:
-221    """Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value "a,b,c" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice."""
-222
-223    considered_multivalue_features = args.explode_multivalue_features.split(
-224        ';',
-225    )
-226    new_feature_hash = {}
-227    missing_symbols = set(args.missing_value_symbols.split(','))
-228
-229    for multivalue_feature in considered_multivalue_features:
-230        multivalue_feature_vector = input_dataframe[multivalue_feature].values.tolist(
-231        )
-232        multivalue_feature_vector = [
-233            x.replace(',', '-') for x in multivalue_feature_vector
-234        ]
-235        multivalue_sets = [
-236            set(x.split('-'))
-237            for x in multivalue_feature_vector
-238        ]
-239        unique_values = set.union(*multivalue_sets)
+215    for multivalue_feature in considered_multivalue_features:
+216        multivalue_feature_vector = input_dataframe[multivalue_feature].values.tolist(
+217        )
+218        multivalue_feature_vector = [
+219            x.replace(',', '-') for x in multivalue_feature_vector
+220        ]
+221        multivalue_sets = [
+222            set(x.split('-'))
+223            for x in multivalue_feature_vector
+224        ]
+225        unique_values = set.union(*multivalue_sets)
+226
+227        for missing_symbol in missing_symbols:
+228            if missing_symbol in unique_values:
+229                unique_values.remove(missing_symbol)
+230
+231        for unique_value in unique_values:
+232            tmp_vec = []
+233            for enx, multivalue in enumerate(multivalue_sets):
+234                if unique_value in multivalue:
+235                    tmp_vec.append('1')
+236                else:
+237                    tmp_vec.append('')
+238
+239            new_feature_hash[f'MULTIEX-{multivalue_feature}-{unique_value}'] = tmp_vec
 240
-241        for missing_symbol in missing_symbols:
-242            if missing_symbol in unique_values:
-243                unique_values.remove(missing_symbol)
+241    tmp_df = pd.DataFrame(new_feature_hash)
+242    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+243    del tmp_df
 244
-245        for unique_value in unique_values:
-246            tmp_vec = []
-247            for enx, multivalue in enumerate(multivalue_sets):
-248                if unique_value in multivalue:
-249                    tmp_vec.append('1')
-250                else:
-251                    tmp_vec.append('')
-252
-253            new_feature_hash[f'MULTIEX-{multivalue_feature}-{unique_value}'] = tmp_vec
-254
-255    tmp_df = pd.DataFrame(new_feature_hash)
-256    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
-257    del tmp_df
+245    return input_dataframe
+246
+247
+248def compute_subfeatures(
+249    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
+250) -> pd.DataFrame:
+251    """Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.
+252    ->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.
+253    <->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
+254    """
+255
+256    all_subfeature_pair_seeds = args.subfeature_mapping.split(';')
+257    new_feature_hash = dict()
 258
-259    return input_dataframe
-260
-261
-262def compute_subfeatures(
-263    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
-264) -> pd.DataFrame:
-265    """Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.
-266    ->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.
-267    <->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
-268    """
-269
-270    all_subfeature_pair_seeds = args.subfeature_mapping.split(';')
-271    new_feature_hash = dict()
-272
-273    for seed_pair in all_subfeature_pair_seeds:
-274        if '<->' in seed_pair:
-275            feature_first, feature_second = seed_pair.split('<->')
-276
-277        elif '->' in seed_pair:
-278            feature_first, feature_second = seed_pair.split('->')
-279
-280        else:
-281            raise NotImplementedError(
-282                'Please specify valid subfeature operator (<-> or ->)',
-283            )
-284
-285        subframe = input_dataframe[[feature_first, feature_second]]
-286        unique_feature_second = subframe[feature_second].unique()
-287        feature_first_vec = subframe[feature_first].tolist()
-288        feature_second_vec = subframe[feature_second].tolist()
-289        out_template_feature = [
-290            (a, b) for a, b in zip(feature_first_vec, feature_second_vec)
-291        ]
-292
-293        if '<->' in seed_pair:
-294            unique_feature_first = subframe[feature_first].unique()
-295
-296            mask_types = []
-297            for unique_target_feature_value in unique_feature_second:
-298                for unique_seed_feature_value in unique_feature_first:
-299                    mask_types.append(
-300                        (unique_seed_feature_value, unique_target_feature_value),
-301                    )
-302
-303            for mask_type in mask_types:
-304                new_feature = []
-305                for value_tuple in out_template_feature:
-306                    if (
-307                        value_tuple[0] == mask_type[0]
-308                        and value_tuple[1] == mask_type[1]
-309                    ):
-310                        new_feature.append(str(1))
-311                    else:
-312                        new_feature.append(str(0))
-313                feature_name = (
-314                    f'SUBFEATURE|{feature_first}|{feature_second}-'
-315                    + mask_type[0]
-316                    + '&'
-317                    + mask_type[1]
-318                )
-319                new_feature_hash[feature_name] = new_feature
-320
-321            del new_feature
-322
-323        elif '->' in seed_pair:
-324            for unique_target_feature_value in unique_feature_second:
-325                tmp_new_feature = [
-326                    'AND'.join(
-327                        x,
-328                    ) if x[1] == unique_target_feature_value else ''
-329                    for x in out_template_feature
-330                ]
-331                feature_name_final = (
-332                    'SUBFEATURE-' + feature_first + '&' + unique_target_feature_value
-333                )
-334                new_feature_hash[feature_name_final] = tmp_new_feature
-335
-336    tmp_df = pd.DataFrame(new_feature_hash)
-337    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+259    for seed_pair in all_subfeature_pair_seeds:
+260        if '<->' in seed_pair:
+261            feature_first, feature_second = seed_pair.split('<->')
+262
+263        elif '->' in seed_pair:
+264            feature_first, feature_second = seed_pair.split('->')
+265
+266        else:
+267            raise NotImplementedError(
+268                'Please specify valid subfeature operator (<-> or ->)',
+269            )
+270
+271        subframe = input_dataframe[[feature_first, feature_second]]
+272        unique_feature_second = subframe[feature_second].unique()
+273        feature_first_vec = subframe[feature_first].tolist()
+274        feature_second_vec = subframe[feature_second].tolist()
+275        out_template_feature = [
+276            (a, b) for a, b in zip(feature_first_vec, feature_second_vec)
+277        ]
+278
+279        if '<->' in seed_pair:
+280            unique_feature_first = subframe[feature_first].unique()
+281
+282            mask_types = []
+283            for unique_target_feature_value in unique_feature_second:
+284                for unique_seed_feature_value in unique_feature_first:
+285                    mask_types.append(
+286                        (unique_seed_feature_value, unique_target_feature_value),
+287                    )
+288
+289            for mask_type in mask_types:
+290                new_feature = []
+291                for value_tuple in out_template_feature:
+292                    if (
+293                        value_tuple[0] == mask_type[0]
+294                        and value_tuple[1] == mask_type[1]
+295                    ):
+296                        new_feature.append(str(1))
+297                    else:
+298                        new_feature.append(str(0))
+299                feature_name = (
+300                    f'SUBFEATURE|{feature_first}|{feature_second}-'
+301                    + mask_type[0]
+302                    + '&'
+303                    + mask_type[1]
+304                )
+305                new_feature_hash[feature_name] = new_feature
+306
+307            del new_feature
+308
+309        elif '->' in seed_pair:
+310            for unique_target_feature_value in unique_feature_second:
+311                tmp_new_feature = [
+312                    'AND'.join(
+313                        x,
+314                    ) if x[1] == unique_target_feature_value else ''
+315                    for x in out_template_feature
+316                ]
+317                feature_name_final = (
+318                    'SUBFEATURE-' + feature_first + '&' + unique_target_feature_value
+319                )
+320                new_feature_hash[feature_name_final] = tmp_new_feature
+321
+322    tmp_df = pd.DataFrame(new_feature_hash)
+323    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+324
+325    del tmp_df
+326    return input_dataframe
+327
+328
+329def include_noisy_features(
+330    input_dataframe: pd.DataFrame, logger: Any, args: Any,
+331) -> pd.DataFrame:
+332    """Add randomized features that serve as a sanity check"""
+333
+334    transformer = FeatureTransformerNoise()
+335    transformed_df = transformer.construct_new_features(
+336        input_dataframe, args.label_column,
+337    )
 338
-339    del tmp_df
-340    return input_dataframe
+339    return transformed_df
+340
 341
-342
-343def include_noisy_features(
-344    input_dataframe: pd.DataFrame, logger: Any, args: Any,
-345) -> pd.DataFrame:
-346    """Add randomized features that serve as a sanity check"""
-347
-348    transformer = FeatureTransformerNoise()
-349    transformed_df = transformer.construct_new_features(
-350        input_dataframe, args.label_column,
-351    )
-352
-353    return transformed_df
-354
-355
-356def compute_coverage(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
-357    """Compute coverage of features, incrementally"""
-358    output_storage_cov = defaultdict(set)
-359    all_missing_symbols = set(args.missing_value_symbols.split(','))
-360    for column in input_dataframe:
-361        all_missing = sum(
-362            [
-363                input_dataframe[column].values.tolist().count(x)
-364                for x in all_missing_symbols
-365            ],
-366        )
-367
-368        output_storage_cov[column] = (
-369            1 - (all_missing / input_dataframe.shape[0])
-370        ) * 100
-371
-372    return output_storage_cov
-373
+342def compute_coverage(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
+343    """Compute coverage of features, incrementally"""
+344    output_storage_cov = defaultdict(set)
+345    all_missing_symbols = set(args.missing_value_symbols.split(','))
+346    for column in input_dataframe:
+347        all_missing = sum(
+348            [
+349                input_dataframe[column].values.tolist().count(x)
+350                for x in all_missing_symbols
+351            ],
+352        )
+353
+354        output_storage_cov[column] = (
+355            1 - (all_missing / input_dataframe.shape[0])
+356        ) * 100
+357
+358    return output_storage_cov
+359
+360
+361def compute_feature_memory_consumption(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
+362    """An approximation of how much feature take up"""
+363    output_storage_features = defaultdict(set)
+364    for col in input_dataframe.columns:
+365        specific_column = [
+366            str(x).strip() for x in input_dataframe[col].astype(str).values.tolist()
+367        ]
+368        col_size = sum(
+369            len(x.encode())
+370            for x in specific_column
+371        ) / input_dataframe.shape[0]
+372        output_storage_features[col] = col_size
+373    return output_storage_features
 374
-375def compute_feature_memory_consumption(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
-376    """An approximation of how much feature take up"""
-377    output_storage_features = defaultdict(set)
-378    for col in input_dataframe.columns:
-379        specific_column = [
-380            str(x).strip() for x in input_dataframe[col].astype(str).values.tolist()
-381        ]
-382        col_size = sum(
-383            len(x.encode())
-384            for x in specific_column
-385        ) / input_dataframe.shape[0]
-386        output_storage_features[col] = col_size
-387    return output_storage_features
-388
-389
-390def compute_value_counts(input_dataframe: pd.DataFrame, args: Any):
-391    """Update the count structure"""
-392
-393    global GLOBAL_RARE_VALUE_STORAGE
-394    global IGNORED_VALUES
+375
+376def compute_value_counts(input_dataframe: pd.DataFrame, args: Any):
+377    """Update the count structure"""
+378
+379    global GLOBAL_RARE_VALUE_STORAGE
+380    global IGNORED_VALUES
+381
+382    for column in input_dataframe.columns:
+383        main_values = input_dataframe[column].values
+384        for value in main_values:
+385            if value not in IGNORED_VALUES:
+386                GLOBAL_RARE_VALUE_STORAGE.update({(column, value): 1})
+387
+388    for key, val in GLOBAL_RARE_VALUE_STORAGE.items():
+389        if val > args.rare_value_count_upper_bound:
+390            IGNORED_VALUES.add(key)
+391
+392    for to_remove_val in IGNORED_VALUES:
+393        del GLOBAL_RARE_VALUE_STORAGE[to_remove_val]
+394
 395
-396    for column in input_dataframe.columns:
-397        main_values = input_dataframe[column].values
-398        for value in main_values:
-399            if value not in IGNORED_VALUES:
-400                GLOBAL_RARE_VALUE_STORAGE.update({(column, value): 1})
-401
-402    for key, val in GLOBAL_RARE_VALUE_STORAGE.items():
-403        if val > args.rare_value_count_upper_bound:
-404            IGNORED_VALUES.add(key)
-405
-406    for to_remove_val in IGNORED_VALUES:
-407        del GLOBAL_RARE_VALUE_STORAGE[to_remove_val]
-408
-409
-410def compute_cardinalities(input_dataframe: pd.DataFrame, pbar: Any) -> None:
-411    """Compute cardinalities of features, incrementally"""
-412
-413    global GLOBAL_CARDINALITY_STORAGE
-414    output_storage_card = defaultdict(set)
-415    for enx, column in enumerate(input_dataframe):
-416        output_storage_card[column] = set(input_dataframe[column].unique())
-417        if column not in GLOBAL_CARDINALITY_STORAGE:
-418            GLOBAL_CARDINALITY_STORAGE[column] = HyperLogLog(
-419                HYPERLL_ERROR_BOUND,
-420            )
-421
-422        for unique_value in set(input_dataframe[column].unique()):
-423            if unique_value:
-424                GLOBAL_CARDINALITY_STORAGE[column].add(
-425                    internal_hash(unique_value),
-426                )
-427        pbar.set_description(
-428            f'Computing cardinality (Hyperloglog update) {enx}/{input_dataframe.shape[1]}',
-429        )
-430
-431
-432def compute_bounds_increment(
-433    input_dataframe: pd.DataFrame, numeric_column_types: set[str],
-434) -> dict[str, Any]:
-435    all_features = input_dataframe.columns
-436    numeric_column_types = set(numeric_column_types)
-437    summary_object = {}
-438    summary_storage: Any = {}
-439    for feature in all_features:
-440        if feature in numeric_column_types:
-441            feature_vector = pd.to_numeric(
-442                input_dataframe[feature], errors='coerce',
-443            )
-444            minimum = np.min(feature_vector)
-445            maximum = np.max(feature_vector)
-446            mean = np.mean(feature_vector)
-447            summary_storage = NumericFeatureSummary(
-448                feature, minimum, maximum, mean, len(
-449                    np.unique(feature_vector),
-450                ),
-451            )
-452            summary_object[feature] = summary_storage
-453
-454        else:
-455            feature_vector = input_dataframe[feature].values
-456            summary_storage = NominalFeatureSummary(
-457                feature, len(np.unique(feature_vector)),
-458            )
-459            summary_object[feature] = summary_storage
+396def compute_cardinalities(input_dataframe: pd.DataFrame, pbar: Any) -> None:
+397    """Compute cardinalities of features, incrementally"""
+398
+399    global GLOBAL_CARDINALITY_STORAGE
+400    output_storage_card = defaultdict(set)
+401    for enx, column in enumerate(input_dataframe):
+402        output_storage_card[column] = set(input_dataframe[column].unique())
+403        if column not in GLOBAL_CARDINALITY_STORAGE:
+404            GLOBAL_CARDINALITY_STORAGE[column] = HyperLogLog(
+405                HYPERLL_ERROR_BOUND,
+406            )
+407
+408        for unique_value in set(input_dataframe[column].unique()):
+409            if unique_value:
+410                GLOBAL_CARDINALITY_STORAGE[column].add(
+411                    internal_hash(unique_value),
+412                )
+413        pbar.set_description(
+414            f'Computing cardinality (Hyperloglog update) {enx}/{input_dataframe.shape[1]}',
+415        )
+416
+417
+418def compute_bounds_increment(
+419    input_dataframe: pd.DataFrame, numeric_column_types: set[str],
+420) -> dict[str, Any]:
+421    all_features = input_dataframe.columns
+422    numeric_column_types = set(numeric_column_types)
+423    summary_object = {}
+424    summary_storage: Any = {}
+425    for feature in all_features:
+426        if feature in numeric_column_types:
+427            feature_vector = pd.to_numeric(
+428                input_dataframe[feature], errors='coerce',
+429            )
+430            minimum = np.min(feature_vector)
+431            maximum = np.max(feature_vector)
+432            mean = np.mean(feature_vector)
+433            summary_storage = NumericFeatureSummary(
+434                feature, minimum, maximum, mean, len(
+435                    np.unique(feature_vector),
+436                ),
+437            )
+438            summary_object[feature] = summary_storage
+439
+440        else:
+441            feature_vector = input_dataframe[feature].values
+442            summary_storage = NominalFeatureSummary(
+443                feature, len(np.unique(feature_vector)),
+444            )
+445            summary_object[feature] = summary_storage
+446
+447    return summary_object
+448
+449
+450def compute_batch_ranking(
+451    line_tmp_storage: list[list[Any]],
+452    numeric_column_types: set[str],
+453    args: Any,
+454    cpu_pool: Any,
+455    column_descriptions: list[str],
+456    logger: Any,
+457    pbar: Any,
+458) -> tuple[BatchRankingSummary, dict[str, Any], dict[str, set[str]], dict[str, set[str]]]:
+459    """Enrich the feature space and compute the batch importances"""
 460
-461    return summary_object
-462
-463
-464def compute_batch_ranking(
-465    line_tmp_storage: list[list[Any]],
-466    numeric_column_types: set[str],
-467    args: Any,
-468    cpu_pool: Any,
-469    column_descriptions: list[str],
-470    logger: Any,
-471    pbar: Any,
-472) -> tuple[BatchRankingSummary, dict[str, Any], dict[str, set[str]], dict[str, set[str]]]:
-473    """Enrich the feature space and compute the batch importances"""
-474
-475    input_dataframe = pd.DataFrame(line_tmp_storage)
-476    input_dataframe.columns = column_descriptions
-477    pbar.set_description('Control features')
-478
-479    if args.feature_set_focus:
-480        if args.feature_set_focus == '_all_from_reference_JSON':
-481            focus_set = extract_features_from_reference_JSON(
-482                args.reference_model_JSON,
-483            )
-484
-485        else:
-486            focus_set = set(args.feature_set_focus.split(','))
-487
-488        focus_set.add(args.label_column)
-489        focus_set = {x for x in focus_set if x in input_dataframe.columns}
-490        input_dataframe = input_dataframe[focus_set]
-491
-492    if args.transformers != 'none':
-493        pbar.set_description('Adding transformations')
-494        input_dataframe = enrich_with_transformations(
-495            input_dataframe, numeric_column_types, logger, args,
-496        )
-497
-498    if args.explode_multivalue_features != 'False':
-499        pbar.set_description('Constructing new features from multivalue ones')
-500        input_dataframe = compute_expanded_multivalue_features(
-501            input_dataframe, logger, args, pbar,
-502        )
-503
-504    if args.subfeature_mapping != 'False':
-505        pbar.set_description('Constructing new (sub)features')
-506        input_dataframe = compute_subfeatures(
-507            input_dataframe, logger, args, pbar,
-508        )
-509
-510    if args.interaction_order > 1:
-511        pbar.set_description('Constructing new features')
-512        input_dataframe = compute_combined_features(
-513            input_dataframe, logger, args, pbar,
-514        )
-515
-516    # in case of 3mr we compute the score of combinations against the target
-517    if '3mr' in args.heuristic:
-518        pbar.set_description(
-519            'Constructing features for computing relations in 3mr',
-520        )
-521        input_dataframe = compute_combined_features(
-522            input_dataframe, logger, args, pbar, True,
-523        )
-524
-525    if args.include_noise_baseline_features == 'True' and args.heuristic != 'Constant':
-526        pbar.set_description('Computing baseline features')
-527        input_dataframe = include_noisy_features(input_dataframe, logger, args)
-528
-529    # Compute incremental statistic useful for data inspection/transformer generation
-530    pbar.set_description('Computing coverage')
-531    coverage_storage = compute_coverage(input_dataframe, args)
-532    feature_memory_consumption = compute_feature_memory_consumption(
-533        input_dataframe, args,
-534    )
-535    compute_cardinalities(input_dataframe, pbar)
-536
-537    if args.task == 'identify_rare_values':
-538        compute_value_counts(input_dataframe, args)
-539
-540    bounds_storage = compute_bounds_increment(
-541        input_dataframe, numeric_column_types,
-542    )
-543
-544    pbar.set_description(
-545        f'Computing ranks for {input_dataframe.shape[1]} features',
-546    )
-547
-548    return (
-549        mixed_rank_graph(input_dataframe, args, cpu_pool, pbar),
-550        bounds_storage,
-551        coverage_storage,
-552        feature_memory_consumption,
-553    )
-554
+461    input_dataframe = pd.DataFrame(line_tmp_storage)
+462    input_dataframe.columns = column_descriptions
+463    pbar.set_description('Control features')
+464
+465    if args.feature_set_focus:
+466        if args.feature_set_focus == '_all_from_reference_JSON':
+467            focus_set = extract_features_from_reference_JSON(
+468                args.reference_model_JSON,
+469            )
+470
+471        else:
+472            focus_set = set(args.feature_set_focus.split(','))
+473
+474        focus_set.add(args.label_column)
+475        focus_set = {x for x in focus_set if x in input_dataframe.columns}
+476        input_dataframe = input_dataframe[focus_set]
+477
+478    if args.transformers != 'none':
+479        pbar.set_description('Adding transformations')
+480        input_dataframe = enrich_with_transformations(
+481            input_dataframe, numeric_column_types, logger, args,
+482        )
+483
+484    if args.explode_multivalue_features != 'False':
+485        pbar.set_description('Constructing new features from multivalue ones')
+486        input_dataframe = compute_expanded_multivalue_features(
+487            input_dataframe, logger, args, pbar,
+488        )
+489
+490    if args.subfeature_mapping != 'False':
+491        pbar.set_description('Constructing new (sub)features')
+492        input_dataframe = compute_subfeatures(
+493            input_dataframe, logger, args, pbar,
+494        )
+495
+496    if args.interaction_order > 1:
+497        pbar.set_description('Constructing new features')
+498        input_dataframe = compute_combined_features(
+499            input_dataframe, logger, args, pbar,
+500        )
+501
+502    # in case of 3mr we compute the score of combinations against the target
+503    if '3mr' in args.heuristic:
+504        pbar.set_description(
+505            'Constructing features for computing relations in 3mr',
+506        )
+507        input_dataframe = compute_combined_features(
+508            input_dataframe, logger, args, pbar, True,
+509        )
+510
+511    if args.include_noise_baseline_features == 'True' and args.heuristic != 'Constant':
+512        pbar.set_description('Computing baseline features')
+513        input_dataframe = include_noisy_features(input_dataframe, logger, args)
+514
+515    # Compute incremental statistic useful for data inspection/transformer generation
+516    pbar.set_description('Computing coverage')
+517    coverage_storage = compute_coverage(input_dataframe, args)
+518    feature_memory_consumption = compute_feature_memory_consumption(
+519        input_dataframe, args,
+520    )
+521    compute_cardinalities(input_dataframe, pbar)
+522
+523    if args.task == 'identify_rare_values':
+524        compute_value_counts(input_dataframe, args)
+525
+526    bounds_storage = compute_bounds_increment(
+527        input_dataframe, numeric_column_types,
+528    )
+529
+530    pbar.set_description(
+531        f'Computing ranks for {input_dataframe.shape[1]} features',
+532    )
+533
+534    return (
+535        mixed_rank_graph(input_dataframe, args, cpu_pool, pbar),
+536        bounds_storage,
+537        coverage_storage,
+538        feature_memory_consumption,
+539    )
+540
+541
+542def get_num_of_instances(fname: str) -> int:
+543    """Count the number of lines in a file, fast - useful for progress logging"""
+544
+545    def _make_gen(reader):
+546        while True:
+547            b = reader(2**16)
+548            if not b:
+549                break
+550            yield b
+551
+552    with open(fname, 'rb') as f:
+553        count = sum(buf.count(b'\n') for buf in _make_gen(f.raw.read))
+554    return count
 555
-556def get_num_of_instances(fname: str) -> int:
-557    """Count the number of lines in a file, fast - useful for progress logging"""
-558
-559    def _make_gen(reader):
-560        while True:
-561            b = reader(2**16)
-562            if not b:
-563                break
-564            yield b
-565
-566    with open(fname, 'rb') as f:
-567        count = sum(buf.count(b'\n') for buf in _make_gen(f.raw.read))
-568    return count
+556
+557def get_grouped_df(importances_df_list: list[tuple[str, str, float]]) -> pd.DataFrame:
+558    """A helper method that enables median-based aggregation after processing"""
+559
+560    importances_df = pd.DataFrame(importances_df_list)
+561    if len(importances_df) == 0:
+562        return None
+563    importances_df.columns = ['FeatureA', 'FeatureB', 'Score']
+564    grouped = importances_df.groupby(
+565        ['FeatureA', 'FeatureB'],
+566    ).median().reset_index()
+567    return grouped
+568
 569
-570
-571def get_grouped_df(importances_df_list: list[tuple[str, str, float]]) -> pd.DataFrame:
-572    """A helper method that enables median-based aggregation after processing"""
-573
-574    importances_df = pd.DataFrame(importances_df_list)
-575    if len(importances_df) == 0:
-576        return None
-577    importances_df.columns = ['FeatureA', 'FeatureB', 'Score']
-578    grouped = importances_df.groupby(
-579        ['FeatureA', 'FeatureB'],
-580    ).median().reset_index()
-581    return grouped
-582
-583
-584def checkpoint_importances_df(importances_batch: list[tuple[str, str, float]]) -> None:
-585    """A helper which stores intermediary state - useful for longer runs"""
-586
-587    gdf = get_grouped_df(importances_batch)
-588    if gdf is not None:
-589        gdf.to_csv('ranking_checkpoint_tmp.tsv', sep='\t')
-590
-591
-592def estimate_importances_minibatches(
-593    input_file: str,
-594    column_descriptions: list,
-595    fw_col_mapping: dict[str, str],
-596    numeric_column_types: set,
-597    batch_size: int = 100000,
-598    args: Any = None,
-599    data_encoding: str = 'utf-8',
-600    cpu_pool: Any = None,
-601    delimiter: str = '\t',
-602    feature_construction_mode: bool = False,
-603    logger: Any = None,
-604) -> tuple[list[dict[str, Any]], Any, dict[Any, Any], list[dict[str, Any]], list[dict[str, set[str]]], defaultdict[str, list[set[str]]], dict[str, Any]]:
-605    """Interaction score estimator - suitable for example for csv-like input data types.
-606    This type of data is normally a single large csv, meaning that minibatch processing needs to
-607    happen during incremental handling of the file (that"s not the case for pre-separated ob data)
-608    """
-609
-610    invalid_line_queue: Any = deque([], maxlen=2**5)
+570def checkpoint_importances_df(importances_batch: list[tuple[str, str, float]]) -> None:
+571    """A helper which stores intermediary state - useful for longer runs"""
+572
+573    gdf = get_grouped_df(importances_batch)
+574    if gdf is not None:
+575        gdf.to_csv('ranking_checkpoint_tmp.tsv', sep='\t')
+576
+577
+578def estimate_importances_minibatches(
+579    input_file: str,
+580    column_descriptions: list,
+581    fw_col_mapping: dict[str, str],
+582    numeric_column_types: set,
+583    batch_size: int = 100000,
+584    args: Any = None,
+585    data_encoding: str = 'utf-8',
+586    cpu_pool: Any = None,
+587    delimiter: str = '\t',
+588    feature_construction_mode: bool = False,
+589    logger: Any = None,
+590) -> tuple[list[dict[str, Any]], Any, dict[Any, Any], list[dict[str, Any]], list[dict[str, set[str]]], defaultdict[str, list[set[str]]], dict[str, Any]]:
+591    """Interaction score estimator - suitable for example for csv-like input data types.
+592    This type of data is normally a single large csv, meaning that minibatch processing needs to
+593    happen during incremental handling of the file (that"s not the case for pre-separated ob data)
+594    """
+595
+596    invalid_line_queue: Any = deque([], maxlen=2**5)
+597
+598    invalid_lines = 0
+599    line_counter = 0
+600
+601    importances_df: list[Any] = []
+602    line_tmp_storage = []
+603    bounds_storage_batch = []
+604    memory_storage_batch = []
+605    step_timing_checkpoints = []
+606
+607    local_coverage_object = defaultdict(list)
+608    local_pbar = tqdm.tqdm(
+609        total=get_num_of_instances(input_file) - 1, position=0,
+610    )
 611
-612    invalid_lines = 0
-613    line_counter = 0
-614
-615    importances_df: list[Any] = []
-616    line_tmp_storage = []
-617    bounds_storage_batch = []
-618    memory_storage_batch = []
-619    step_timing_checkpoints = []
-620
-621    local_coverage_object = defaultdict(list)
-622    local_pbar = tqdm.tqdm(
-623        total=get_num_of_instances(input_file) - 1, position=0,
-624    )
-625
-626    file_name, file_extension = os.path.splitext(input_file)
-627
-628    if file_extension == '.gz':
-629        file_stream = gzip.open(input_file, 'rt', encoding=data_encoding)
-630
-631    else:
-632        file_stream = open(input_file, encoding=data_encoding)
+612    file_name, file_extension = os.path.splitext(input_file)
+613
+614    if file_extension == '.gz':
+615        file_stream = gzip.open(input_file, 'rt', encoding=data_encoding)
+616
+617    else:
+618        file_stream = open(input_file, encoding=data_encoding)
+619
+620    file_stream.readline()
+621
+622    local_pbar.set_description('Starting ranking computation')
+623    for line in file_stream:
+624        line_counter += 1
+625        local_pbar.update(1)
+626
+627        if line_counter % args.subsampling != 0:
+628            continue
+629
+630        parsed_line = generic_line_parser(
+631            line, delimiter, args, fw_col_mapping, column_descriptions,
+632        )
 633
-634    file_stream.readline()
-635
-636    local_pbar.set_description('Starting ranking computation')
-637    for line in file_stream:
-638        line_counter += 1
-639        local_pbar.update(1)
+634        if len(parsed_line) == len(column_descriptions):
+635            line_tmp_storage.append(parsed_line)
+636
+637        else:
+638            invalid_line_queue.appendleft(str(parsed_line))
+639            invalid_lines += 1
 640
-641        if line_counter % args.subsampling != 0:
-642            continue
+641        # Batches need to be processed on-the-fly
+642        if len(line_tmp_storage) >= args.minibatch_size:
 643
-644        parsed_line = generic_line_parser(
-645            line, delimiter, args, fw_col_mapping, column_descriptions,
-646        )
-647
-648        if len(parsed_line) == len(column_descriptions):
-649            line_tmp_storage.append(parsed_line)
-650
-651        else:
-652            invalid_line_queue.appendleft(str(parsed_line))
-653            invalid_lines += 1
-654
-655        # Batches need to be processed on-the-fly
-656        if len(line_tmp_storage) >= args.minibatch_size:
-657
-658            importances_batch, bounds_storage, coverage_storage, memory_storage = compute_batch_ranking(
-659                line_tmp_storage,
-660                numeric_column_types,
-661                args,
-662                cpu_pool,
-663                column_descriptions,
-664                logger,
-665                local_pbar,
-666            )
-667
-668            bounds_storage_batch.append(bounds_storage)
-669            memory_storage_batch.append(memory_storage)
-670            for k, v in coverage_storage.items():
-671                local_coverage_object[k].append(v)
-672
-673            del coverage_storage
-674
-675            line_tmp_storage = []
-676            step_timing_checkpoints.append(importances_batch.step_times)
-677            importances_df += importances_batch.triplet_scores
-678
-679            if args.heuristic != 'Constant':
-680                local_pbar.set_description('Creating checkpoint')
-681                checkpoint_importances_df(importances_df)
-682
-683    file_stream.close()
-684
-685    local_pbar.set_description('Parsing the remainder')
-686    if invalid_lines > 0:
-687        logger.info(
-688            f"Detected {invalid_lines} invalid lines. If this number is very high, it's possible your header is off - re-check your data/attribute-feature mappings please!",
-689        )
-690
-691        invalid_lines_log = '\n INVALID_LINE ====> '.join(
-692            list(invalid_line_queue)[0:5],
-693        )
-694        logger.info(
-695            f'5 samples of invalid lines are printed below\n {invalid_lines_log}',
+644            importances_batch, bounds_storage, coverage_storage, memory_storage = compute_batch_ranking(
+645                line_tmp_storage,
+646                numeric_column_types,
+647                args,
+648                cpu_pool,
+649                column_descriptions,
+650                logger,
+651                local_pbar,
+652            )
+653
+654            bounds_storage_batch.append(bounds_storage)
+655            memory_storage_batch.append(memory_storage)
+656            for k, v in coverage_storage.items():
+657                local_coverage_object[k].append(v)
+658
+659            del coverage_storage
+660
+661            line_tmp_storage = []
+662            step_timing_checkpoints.append(importances_batch.step_times)
+663            importances_df += importances_batch.triplet_scores
+664
+665            if args.heuristic != 'Constant':
+666                local_pbar.set_description('Creating checkpoint')
+667                checkpoint_importances_df(importances_df)
+668
+669    file_stream.close()
+670
+671    local_pbar.set_description('Parsing the remainder')
+672    if invalid_lines > 0:
+673        logger.info(
+674            f"Detected {invalid_lines} invalid lines. If this number is very high, it's possible your header is off - re-check your data/attribute-feature mappings please!",
+675        )
+676
+677        invalid_lines_log = '\n INVALID_LINE ====> '.join(
+678            list(invalid_line_queue)[0:5],
+679        )
+680        logger.info(
+681            f'5 samples of invalid lines are printed below\n {invalid_lines_log}',
+682        )
+683
+684    remaining_batch_size = len(line_tmp_storage)
+685
+686    if remaining_batch_size > 2**10:
+687        line_tmp_storage = line_tmp_storage[: args.minibatch_size]
+688        importances_batch, bounds_storage, coverage_storage, _ = compute_batch_ranking(
+689            line_tmp_storage,
+690            numeric_column_types,
+691            args,
+692            cpu_pool,
+693            column_descriptions,
+694            logger,
+695            local_pbar,
 696        )
 697
-698    remaining_batch_size = len(line_tmp_storage)
-699
-700    if remaining_batch_size > 2**10:
-701        line_tmp_storage = line_tmp_storage[: args.minibatch_size]
-702        importances_batch, bounds_storage, coverage_storage, _ = compute_batch_ranking(
-703            line_tmp_storage,
-704            numeric_column_types,
-705            args,
-706            cpu_pool,
-707            column_descriptions,
-708            logger,
-709            local_pbar,
-710        )
-711
-712        for k, v in coverage_storage.items():
-713            local_coverage_object[k].append(v)
-714
-715        step_timing_checkpoints.append(importances_batch.step_times)
-716        importances_df += importances_batch.triplet_scores
-717        bounds_storage = dict()
-718        bounds_storage_batch.append(bounds_storage)
-719        checkpoint_importances_df(importances_df)
-720
-721    local_pbar.set_description('Wrapping up')
-722    local_pbar.close()
-723
-724    return (
-725        step_timing_checkpoints,
-726        get_grouped_df(importances_df),
-727        GLOBAL_CARDINALITY_STORAGE,
-728        bounds_storage_batch,
-729        memory_storage_batch,
-730        local_coverage_object,
-731        GLOBAL_RARE_VALUE_STORAGE,
-732    )
+698        for k, v in coverage_storage.items():
+699            local_coverage_object[k].append(v)
+700
+701        step_timing_checkpoints.append(importances_batch.step_times)
+702        importances_df += importances_batch.triplet_scores
+703        bounds_storage = dict()
+704        bounds_storage_batch.append(bounds_storage)
+705        checkpoint_importances_df(importances_df)
+706
+707    local_pbar.set_description('Wrapping up')
+708    local_pbar.close()
+709
+710    return (
+711        step_timing_checkpoints,
+712        get_grouped_df(importances_df),
+713        GLOBAL_CARDINALITY_STORAGE,
+714        bounds_storage_batch,
+715        memory_storage_batch,
+716        local_coverage_object,
+717        GLOBAL_RARE_VALUE_STORAGE,
+718    )
    @@ -912,30 +895,6 @@

    -

    -
    - -
    - - def - encode_int_column(input_tuple: tuple[str, typing.Any]) -> tuple[typing.Any, list[int]]: - - - -
    - - 
    48def encode_int_column(input_tuple: tuple[str, Any]) -> tuple[Any, list[int]]:
-49    """Encode column values as categoric (at a batch level!)"""
-50
-51    hashes, _ = pd.factorize(input_tuple[1])
-52    return input_tuple[0], hashes
-
    - - -

    Encode column values as categoric (at a batch level!)

    -
    - -
    @@ -948,101 +907,94 @@

    - 
     55def mixed_rank_graph(
- 56    input_dataframe: pd.DataFrame, args: Any, cpu_pool: Any, pbar: Any,
- 57) -> BatchRankingSummary:
- 58    """Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic"""
- 59
- 60    all_columns = input_dataframe.columns
- 61
- 62    triplets = []
- 63    tmp_df = input_dataframe.copy()
- 64    out_time_struct = {}
- 65
- 66    # Handle cont. types prior to interaction evaluation
- 67    pbar.set_description('Encoding columns')
- 68    jobs = [(cname, tmp_df[cname]) for cname in all_columns]
- 69    col_dots = '.'
- 70    start_enc_timer = timer()
- 71    with cpu_pool as p:
- 72        results = p.amap(encode_int_column, jobs)
- 73        while not results.ready():
- 74            time.sleep(4)
- 75            col_dots = col_dots + '.'
- 76            pbar.set_description(f'Encoding columns .{col_dots}')
- 77        tmp_df = pd.DataFrame({k: v for k, v in results.get()})
- 78    end_enc_timer = timer()
- 79    out_time_struct['encoding_columns'] = end_enc_timer - start_enc_timer
- 80
- 81    # Helper method for parallel estimation
- 82    combinations = list(
- 83        itertools.combinations_with_replacement(all_columns, 2),
- 84    )
+            
     48def mixed_rank_graph(
+ 49    input_dataframe: pd.DataFrame, args: Any, cpu_pool: Any, pbar: Any,
+ 50) -> BatchRankingSummary:
+ 51    """Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic"""
+ 52
+ 53    all_columns = input_dataframe.columns
+ 54
+ 55    triplets = []
+ 56    tmp_df = input_dataframe.copy().astype('category')
+ 57    out_time_struct = {}
+ 58
+ 59    # Handle cont. types prior to interaction evaluation
+ 60    pbar.set_description('Encoding columns')
+ 61    col_dots = '.'
+ 62    start_enc_timer = timer()
+ 63    tmp_df = pd.DataFrame({k : tmp_df[k].cat.codes for k in all_columns})
+ 64    end_enc_timer = timer()
+ 65    out_time_struct['encoding_columns'] = end_enc_timer - start_enc_timer
+ 66
+ 67    # Helper method for parallel estimation
+ 68    combinations = list(
+ 69        itertools.combinations_with_replacement(all_columns, 2),
+ 70    )
+ 71
+ 72    if '3mr' in args.heuristic:
+ 73        rel_columns = [
+ 74            column for column in all_columns if ' AND_REL ' in column
+ 75        ]
+ 76        non_rel_columns = list(set(all_columns) - set(rel_columns))
+ 77        combinations = list(
+ 78            itertools.combinations_with_replacement(non_rel_columns, 2),
+ 79        )
+ 80        combinations += [(column, args.label_column) for column in rel_columns]
+ 81    else:
+ 82        combinations = list(
+ 83            itertools.combinations_with_replacement(all_columns, 2),
+ 84        )
  85
- 86    if '3mr' in args.heuristic:
- 87        rel_columns = [
- 88            column for column in all_columns if ' AND_REL ' in column
- 89        ]
- 90        non_rel_columns = list(set(all_columns) - set(rel_columns))
- 91        combinations = list(
- 92            itertools.combinations_with_replacement(non_rel_columns, 2),
- 93        )
- 94        combinations += [(column, args.label_column) for column in rel_columns]
- 95    else:
- 96        combinations = list(
- 97            itertools.combinations_with_replacement(all_columns, 2),
- 98        )
- 99
-100    # Diagonal elements
-101    for individual_column in all_columns:
-102        if individual_column != args.label_column:
-103            combinations += [(individual_column, individual_column)]
-104
-105    # Some applications do not require the full feature-feature triangular matrix
-106    if (args.target_ranking_only == 'True') and ('3mr' not in args.heuristic):
-107        combinations = [x for x in combinations if args.label_column in x]
-108
-109    random.shuffle(combinations)
-110    combinations = combinations[: args.combination_number_upper_bound]
-111
-112    if args.heuristic == 'Constant':
-113        final_constant_imp = []
-114        for c1, c2 in combinations:
-115            final_constant_imp.append((c1, c2, 0.0))
-116
-117        out_time_struct['feature_score_computation'] = end_enc_timer - \
-118            start_enc_timer
-119        return BatchRankingSummary(final_constant_imp, out_time_struct)
-120
-121    # Map the scoring calls to the worker pool
-122    pbar.set_description('Allocating thread pool')
-123
-124    # starmap is an alternative that is slower unfortunately (but nicer)
-125    def get_grounded_importances_estimate(combination: tuple[str]) -> Any:
-126        return get_importances_estimate_pairwise(combination, args, tmp_df=tmp_df)
-127
-128    start_enc_timer = timer()
-129    with cpu_pool as p:
-130        pbar.set_description(f'Computing (#ftr={len(combinations)})')
-131        results = p.amap(get_grounded_importances_estimate, combinations)
-132        while not results.ready():
-133            time.sleep(4)
-134        triplets = results.get()
-135    end_enc_timer = timer()
-136    out_time_struct['feature_score_computation'] = end_enc_timer - \
-137        start_enc_timer
-138
-139    # Gather the final triplets
-140    pbar.set_description('Aggregation of ranking results')
-141    final_triplets = []
-142    for triplet in triplets:
-143        inv = (triplet[1], triplet[0], triplet[2])
-144        final_triplets.append(inv)
-145        final_triplets.append(triplet)
-146        triplets = final_triplets
-147
-148    pbar.set_description('Proceeding to the next batch of data')
-149    return BatchRankingSummary(triplets, out_time_struct)
+ 86    # Diagonal elements
+ 87    for individual_column in all_columns:
+ 88        if individual_column != args.label_column:
+ 89            combinations += [(individual_column, individual_column)]
+ 90
+ 91    # Some applications do not require the full feature-feature triangular matrix
+ 92    if (args.target_ranking_only == 'True') and ('3mr' not in args.heuristic):
+ 93        combinations = [x for x in combinations if args.label_column in x]
+ 94
+ 95    random.shuffle(combinations)
+ 96    combinations = combinations[: args.combination_number_upper_bound]
+ 97
+ 98    if args.heuristic == 'Constant':
+ 99        final_constant_imp = []
+100        for c1, c2 in combinations:
+101            final_constant_imp.append((c1, c2, 0.0))
+102
+103        out_time_struct['feature_score_computation'] = end_enc_timer - \
+104            start_enc_timer
+105        return BatchRankingSummary(final_constant_imp, out_time_struct)
+106
+107    # Map the scoring calls to the worker pool
+108    pbar.set_description('Allocating thread pool')
+109
+110    # starmap is an alternative that is slower unfortunately (but nicer)
+111    def get_grounded_importances_estimate(combination: tuple[str]) -> Any:
+112        return get_importances_estimate_pairwise(combination, args, tmp_df=tmp_df)
+113
+114    start_enc_timer = timer()
+115    with cpu_pool as p:
+116        pbar.set_description(f'Computing (#ftr={len(combinations)})')
+117        results = p.amap(get_grounded_importances_estimate, combinations)
+118        while not results.ready():
+119            time.sleep(4)
+120        triplets = results.get()
+121    end_enc_timer = timer()
+122    out_time_struct['feature_score_computation'] = end_enc_timer - \
+123        start_enc_timer
+124
+125    # Gather the final triplets
+126    pbar.set_description('Aggregation of ranking results')
+127    final_triplets = []
+128    for triplet in triplets:
+129        inv = (triplet[1], triplet[0], triplet[2])
+130        final_triplets.append(inv)
+131        final_triplets.append(triplet)
+132        triplets = final_triplets
+133
+134    pbar.set_description('Proceeding to the next batch of data')
+135    return BatchRankingSummary(triplets, out_time_struct)
 
    
 
 
@@ -1062,20 +1014,20 @@
    - 
    152def enrich_with_transformations(
-153    input_dataframe: pd.DataFrame, num_col_types: set[str], logger: Any, args: Any,
-154) -> pd.DataFrame:
-155    """Construct a collection of new features based on pre-defined transformations/rules"""
-156
-157    transformer = FeatureTransformerGeneric(
-158        num_col_types, preset=args.transformers,
-159    )
-160    transformed_df = transformer.construct_new_features(input_dataframe)
-161    logger.info(
-162        f'Constructed {len(transformer.constructed_feature_names)} new features ..',
-163    )
-164
-165    return transformed_df
+            
    138def enrich_with_transformations(
+139    input_dataframe: pd.DataFrame, num_col_types: set[str], logger: Any, args: Any,
+140) -> pd.DataFrame:
+141    """Construct a collection of new features based on pre-defined transformations/rules"""
+142
+143    transformer = FeatureTransformerGeneric(
+144        num_col_types, preset=args.transformers,
+145    )
+146    transformed_df = transformer.construct_new_features(input_dataframe)
+147    logger.info(
+148        f'Constructed {len(transformer.constructed_feature_names)} new features ..',
+149    )
+150
+151    return transformed_df
 
    
 
 
@@ -1095,55 +1047,55 @@
    - 
    168def compute_combined_features(
-169    input_dataframe: pd.DataFrame,
-170    logger: Any,
-171    args: Any,
-172    pbar: Any,
-173    is_3mr: bool = False,
-174) -> pd.DataFrame:
-175    """Compute higher order features via xxhash-based trick."""
-176
-177    all_columns = [
-178        x for x in input_dataframe.columns if x != args.label_column
-179    ]
-180    join_string = ' AND_REL ' if is_3mr else ' AND '
-181    interaction_order = 2 if is_3mr else args.interaction_order
-182
-183    full_combination_space = list(
-184        itertools.combinations(all_columns, interaction_order),
-185    )
-186
-187    if args.combination_number_upper_bound:
-188        random.shuffle(full_combination_space)
-189        full_combination_space = full_combination_space[
-190            : args.combination_number_upper_bound
-191        ]
-192
-193    com_counter = 0
-194    new_feature_hash = {}
-195    for new_combination in full_combination_space:
-196        pbar.set_description(
-197            f'Created {com_counter}/{len(full_combination_space)}',
-198        )
-199        combined_feature: list[str] = [str(0)] * input_dataframe.shape[0]
-200        for feature in new_combination:
-201            tmp_feature = input_dataframe[feature].tolist()
-202            for enx, el in enumerate(tmp_feature):
-203                combined_feature[enx] = str(
-204                    internal_hash(
-205                        str(combined_feature[enx]) + str(el),
-206                    ),
-207                )
-208        ftr_name = join_string.join(str(x) for x in new_combination)
-209        new_feature_hash[ftr_name] = combined_feature
-210        com_counter += 1
-211    tmp_df = pd.DataFrame(new_feature_hash)
-212    pbar.set_description('Concatenating into final frame ..')
-213    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
-214    del tmp_df
-215
-216    return input_dataframe
+            
    154def compute_combined_features(
+155    input_dataframe: pd.DataFrame,
+156    logger: Any,
+157    args: Any,
+158    pbar: Any,
+159    is_3mr: bool = False,
+160) -> pd.DataFrame:
+161    """Compute higher order features via xxhash-based trick."""
+162
+163    all_columns = [
+164        x for x in input_dataframe.columns if x != args.label_column
+165    ]
+166    join_string = ' AND_REL ' if is_3mr else ' AND '
+167    interaction_order = 2 if is_3mr else args.interaction_order
+168
+169    full_combination_space = list(
+170        itertools.combinations(all_columns, interaction_order),
+171    )
+172
+173    if args.combination_number_upper_bound:
+174        random.shuffle(full_combination_space)
+175        full_combination_space = full_combination_space[
+176            : args.combination_number_upper_bound
+177        ]
+178
+179    com_counter = 0
+180    new_feature_hash = {}
+181    for new_combination in full_combination_space:
+182        pbar.set_description(
+183            f'Created {com_counter}/{len(full_combination_space)}',
+184        )
+185        combined_feature: list[str] = [str(0)] * input_dataframe.shape[0]
+186        for feature in new_combination:
+187            tmp_feature = input_dataframe[feature].tolist()
+188            for enx, el in enumerate(tmp_feature):
+189                combined_feature[enx] = str(
+190                    internal_hash(
+191                        str(combined_feature[enx]) + str(el),
+192                    ),
+193                )
+194        ftr_name = join_string.join(str(x) for x in new_combination)
+195        new_feature_hash[ftr_name] = combined_feature
+196        com_counter += 1
+197    tmp_df = pd.DataFrame(new_feature_hash)
+198    pbar.set_description('Concatenating into final frame ..')
+199    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+200    del tmp_df
+201
+202    return input_dataframe
 
    
 
 
@@ -1163,48 +1115,48 @@
    - 
    219def compute_expanded_multivalue_features(
-220    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
-221) -> pd.DataFrame:
-222    """Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value "a,b,c" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice."""
-223
-224    considered_multivalue_features = args.explode_multivalue_features.split(
-225        ';',
-226    )
-227    new_feature_hash = {}
-228    missing_symbols = set(args.missing_value_symbols.split(','))
-229
-230    for multivalue_feature in considered_multivalue_features:
-231        multivalue_feature_vector = input_dataframe[multivalue_feature].values.tolist(
-232        )
-233        multivalue_feature_vector = [
-234            x.replace(',', '-') for x in multivalue_feature_vector
-235        ]
-236        multivalue_sets = [
-237            set(x.split('-'))
-238            for x in multivalue_feature_vector
-239        ]
-240        unique_values = set.union(*multivalue_sets)
+            
    205def compute_expanded_multivalue_features(
+206    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
+207) -> pd.DataFrame:
+208    """Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value "a,b,c" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice."""
+209
+210    considered_multivalue_features = args.explode_multivalue_features.split(
+211        ';',
+212    )
+213    new_feature_hash = {}
+214    missing_symbols = set(args.missing_value_symbols.split(','))
+215
+216    for multivalue_feature in considered_multivalue_features:
+217        multivalue_feature_vector = input_dataframe[multivalue_feature].values.tolist(
+218        )
+219        multivalue_feature_vector = [
+220            x.replace(',', '-') for x in multivalue_feature_vector
+221        ]
+222        multivalue_sets = [
+223            set(x.split('-'))
+224            for x in multivalue_feature_vector
+225        ]
+226        unique_values = set.union(*multivalue_sets)
+227
+228        for missing_symbol in missing_symbols:
+229            if missing_symbol in unique_values:
+230                unique_values.remove(missing_symbol)
+231
+232        for unique_value in unique_values:
+233            tmp_vec = []
+234            for enx, multivalue in enumerate(multivalue_sets):
+235                if unique_value in multivalue:
+236                    tmp_vec.append('1')
+237                else:
+238                    tmp_vec.append('')
+239
+240            new_feature_hash[f'MULTIEX-{multivalue_feature}-{unique_value}'] = tmp_vec
 241
-242        for missing_symbol in missing_symbols:
-243            if missing_symbol in unique_values:
-244                unique_values.remove(missing_symbol)
+242    tmp_df = pd.DataFrame(new_feature_hash)
+243    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+244    del tmp_df
 245
-246        for unique_value in unique_values:
-247            tmp_vec = []
-248            for enx, multivalue in enumerate(multivalue_sets):
-249                if unique_value in multivalue:
-250                    tmp_vec.append('1')
-251                else:
-252                    tmp_vec.append('')
-253
-254            new_feature_hash[f'MULTIEX-{multivalue_feature}-{unique_value}'] = tmp_vec
-255
-256    tmp_df = pd.DataFrame(new_feature_hash)
-257    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
-258    del tmp_df
-259
-260    return input_dataframe
+246    return input_dataframe
 
    
 
 
@@ -1224,85 +1176,85 @@
    - 
    263def compute_subfeatures(
-264    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
-265) -> pd.DataFrame:
-266    """Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.
-267    ->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.
-268    <->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
-269    """
-270
-271    all_subfeature_pair_seeds = args.subfeature_mapping.split(';')
-272    new_feature_hash = dict()
-273
-274    for seed_pair in all_subfeature_pair_seeds:
-275        if '<->' in seed_pair:
-276            feature_first, feature_second = seed_pair.split('<->')
-277
-278        elif '->' in seed_pair:
-279            feature_first, feature_second = seed_pair.split('->')
-280
-281        else:
-282            raise NotImplementedError(
-283                'Please specify valid subfeature operator (<-> or ->)',
-284            )
-285
-286        subframe = input_dataframe[[feature_first, feature_second]]
-287        unique_feature_second = subframe[feature_second].unique()
-288        feature_first_vec = subframe[feature_first].tolist()
-289        feature_second_vec = subframe[feature_second].tolist()
-290        out_template_feature = [
-291            (a, b) for a, b in zip(feature_first_vec, feature_second_vec)
-292        ]
-293
-294        if '<->' in seed_pair:
-295            unique_feature_first = subframe[feature_first].unique()
-296
-297            mask_types = []
-298            for unique_target_feature_value in unique_feature_second:
-299                for unique_seed_feature_value in unique_feature_first:
-300                    mask_types.append(
-301                        (unique_seed_feature_value, unique_target_feature_value),
-302                    )
-303
-304            for mask_type in mask_types:
-305                new_feature = []
-306                for value_tuple in out_template_feature:
-307                    if (
-308                        value_tuple[0] == mask_type[0]
-309                        and value_tuple[1] == mask_type[1]
-310                    ):
-311                        new_feature.append(str(1))
-312                    else:
-313                        new_feature.append(str(0))
-314                feature_name = (
-315                    f'SUBFEATURE|{feature_first}|{feature_second}-'
-316                    + mask_type[0]
-317                    + '&'
-318                    + mask_type[1]
-319                )
-320                new_feature_hash[feature_name] = new_feature
-321
-322            del new_feature
-323
-324        elif '->' in seed_pair:
-325            for unique_target_feature_value in unique_feature_second:
-326                tmp_new_feature = [
-327                    'AND'.join(
-328                        x,
-329                    ) if x[1] == unique_target_feature_value else ''
-330                    for x in out_template_feature
-331                ]
-332                feature_name_final = (
-333                    'SUBFEATURE-' + feature_first + '&' + unique_target_feature_value
-334                )
-335                new_feature_hash[feature_name_final] = tmp_new_feature
-336
-337    tmp_df = pd.DataFrame(new_feature_hash)
-338    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
-339
-340    del tmp_df
-341    return input_dataframe
+            
    249def compute_subfeatures(
+250    input_dataframe: pd.DataFrame, logger: Any, args: Any, pbar: Any,
+251) -> pd.DataFrame:
+252    """Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.
+253    ->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.
+254    <->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
+255    """
+256
+257    all_subfeature_pair_seeds = args.subfeature_mapping.split(';')
+258    new_feature_hash = dict()
+259
+260    for seed_pair in all_subfeature_pair_seeds:
+261        if '<->' in seed_pair:
+262            feature_first, feature_second = seed_pair.split('<->')
+263
+264        elif '->' in seed_pair:
+265            feature_first, feature_second = seed_pair.split('->')
+266
+267        else:
+268            raise NotImplementedError(
+269                'Please specify valid subfeature operator (<-> or ->)',
+270            )
+271
+272        subframe = input_dataframe[[feature_first, feature_second]]
+273        unique_feature_second = subframe[feature_second].unique()
+274        feature_first_vec = subframe[feature_first].tolist()
+275        feature_second_vec = subframe[feature_second].tolist()
+276        out_template_feature = [
+277            (a, b) for a, b in zip(feature_first_vec, feature_second_vec)
+278        ]
+279
+280        if '<->' in seed_pair:
+281            unique_feature_first = subframe[feature_first].unique()
+282
+283            mask_types = []
+284            for unique_target_feature_value in unique_feature_second:
+285                for unique_seed_feature_value in unique_feature_first:
+286                    mask_types.append(
+287                        (unique_seed_feature_value, unique_target_feature_value),
+288                    )
+289
+290            for mask_type in mask_types:
+291                new_feature = []
+292                for value_tuple in out_template_feature:
+293                    if (
+294                        value_tuple[0] == mask_type[0]
+295                        and value_tuple[1] == mask_type[1]
+296                    ):
+297                        new_feature.append(str(1))
+298                    else:
+299                        new_feature.append(str(0))
+300                feature_name = (
+301                    f'SUBFEATURE|{feature_first}|{feature_second}-'
+302                    + mask_type[0]
+303                    + '&'
+304                    + mask_type[1]
+305                )
+306                new_feature_hash[feature_name] = new_feature
+307
+308            del new_feature
+309
+310        elif '->' in seed_pair:
+311            for unique_target_feature_value in unique_feature_second:
+312                tmp_new_feature = [
+313                    'AND'.join(
+314                        x,
+315                    ) if x[1] == unique_target_feature_value else ''
+316                    for x in out_template_feature
+317                ]
+318                feature_name_final = (
+319                    'SUBFEATURE-' + feature_first + '&' + unique_target_feature_value
+320                )
+321                new_feature_hash[feature_name_final] = tmp_new_feature
+322
+323    tmp_df = pd.DataFrame(new_feature_hash)
+324    input_dataframe = pd.concat([input_dataframe, tmp_df], axis=1)
+325
+326    del tmp_df
+327    return input_dataframe
 
    
 
 
@@ -1324,17 +1276,17 @@
    - 
    344def include_noisy_features(
-345    input_dataframe: pd.DataFrame, logger: Any, args: Any,
-346) -> pd.DataFrame:
-347    """Add randomized features that serve as a sanity check"""
-348
-349    transformer = FeatureTransformerNoise()
-350    transformed_df = transformer.construct_new_features(
-351        input_dataframe, args.label_column,
-352    )
-353
-354    return transformed_df
+            
    330def include_noisy_features(
+331    input_dataframe: pd.DataFrame, logger: Any, args: Any,
+332) -> pd.DataFrame:
+333    """Add randomized features that serve as a sanity check"""
+334
+335    transformer = FeatureTransformerNoise()
+336    transformed_df = transformer.construct_new_features(
+337        input_dataframe, args.label_column,
+338    )
+339
+340    return transformed_df
 
    
 
 
@@ -1354,23 +1306,23 @@
    - 
    357def compute_coverage(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
-358    """Compute coverage of features, incrementally"""
-359    output_storage_cov = defaultdict(set)
-360    all_missing_symbols = set(args.missing_value_symbols.split(','))
-361    for column in input_dataframe:
-362        all_missing = sum(
-363            [
-364                input_dataframe[column].values.tolist().count(x)
-365                for x in all_missing_symbols
-366            ],
-367        )
-368
-369        output_storage_cov[column] = (
-370            1 - (all_missing / input_dataframe.shape[0])
-371        ) * 100
-372
-373    return output_storage_cov
+            
    343def compute_coverage(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
+344    """Compute coverage of features, incrementally"""
+345    output_storage_cov = defaultdict(set)
+346    all_missing_symbols = set(args.missing_value_symbols.split(','))
+347    for column in input_dataframe:
+348        all_missing = sum(
+349            [
+350                input_dataframe[column].values.tolist().count(x)
+351                for x in all_missing_symbols
+352            ],
+353        )
+354
+355        output_storage_cov[column] = (
+356            1 - (all_missing / input_dataframe.shape[0])
+357        ) * 100
+358
+359    return output_storage_cov
 
    
 
 
@@ -1390,19 +1342,19 @@
    - 
    376def compute_feature_memory_consumption(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
-377    """An approximation of how much feature take up"""
-378    output_storage_features = defaultdict(set)
-379    for col in input_dataframe.columns:
-380        specific_column = [
-381            str(x).strip() for x in input_dataframe[col].astype(str).values.tolist()
-382        ]
-383        col_size = sum(
-384            len(x.encode())
-385            for x in specific_column
-386        ) / input_dataframe.shape[0]
-387        output_storage_features[col] = col_size
-388    return output_storage_features
+            
    362def compute_feature_memory_consumption(input_dataframe: pd.DataFrame, args: Any) -> dict[str, set[str]]:
+363    """An approximation of how much feature take up"""
+364    output_storage_features = defaultdict(set)
+365    for col in input_dataframe.columns:
+366        specific_column = [
+367            str(x).strip() for x in input_dataframe[col].astype(str).values.tolist()
+368        ]
+369        col_size = sum(
+370            len(x.encode())
+371            for x in specific_column
+372        ) / input_dataframe.shape[0]
+373        output_storage_features[col] = col_size
+374    return output_storage_features
 
    
 
 
@@ -1422,24 +1374,24 @@
    - 
    391def compute_value_counts(input_dataframe: pd.DataFrame, args: Any):
-392    """Update the count structure"""
-393
-394    global GLOBAL_RARE_VALUE_STORAGE
-395    global IGNORED_VALUES
-396
-397    for column in input_dataframe.columns:
-398        main_values = input_dataframe[column].values
-399        for value in main_values:
-400            if value not in IGNORED_VALUES:
-401                GLOBAL_RARE_VALUE_STORAGE.update({(column, value): 1})
-402
-403    for key, val in GLOBAL_RARE_VALUE_STORAGE.items():
-404        if val > args.rare_value_count_upper_bound:
-405            IGNORED_VALUES.add(key)
-406
-407    for to_remove_val in IGNORED_VALUES:
-408        del GLOBAL_RARE_VALUE_STORAGE[to_remove_val]
+            
    377def compute_value_counts(input_dataframe: pd.DataFrame, args: Any):
+378    """Update the count structure"""
+379
+380    global GLOBAL_RARE_VALUE_STORAGE
+381    global IGNORED_VALUES
+382
+383    for column in input_dataframe.columns:
+384        main_values = input_dataframe[column].values
+385        for value in main_values:
+386            if value not in IGNORED_VALUES:
+387                GLOBAL_RARE_VALUE_STORAGE.update({(column, value): 1})
+388
+389    for key, val in GLOBAL_RARE_VALUE_STORAGE.items():
+390        if val > args.rare_value_count_upper_bound:
+391            IGNORED_VALUES.add(key)
+392
+393    for to_remove_val in IGNORED_VALUES:
+394        del GLOBAL_RARE_VALUE_STORAGE[to_remove_val]
 
    
 
 
@@ -1459,26 +1411,26 @@
    - 
    411def compute_cardinalities(input_dataframe: pd.DataFrame, pbar: Any) -> None:
-412    """Compute cardinalities of features, incrementally"""
-413
-414    global GLOBAL_CARDINALITY_STORAGE
-415    output_storage_card = defaultdict(set)
-416    for enx, column in enumerate(input_dataframe):
-417        output_storage_card[column] = set(input_dataframe[column].unique())
-418        if column not in GLOBAL_CARDINALITY_STORAGE:
-419            GLOBAL_CARDINALITY_STORAGE[column] = HyperLogLog(
-420                HYPERLL_ERROR_BOUND,
-421            )
-422
-423        for unique_value in set(input_dataframe[column].unique()):
-424            if unique_value:
-425                GLOBAL_CARDINALITY_STORAGE[column].add(
-426                    internal_hash(unique_value),
-427                )
-428        pbar.set_description(
-429            f'Computing cardinality (Hyperloglog update) {enx}/{input_dataframe.shape[1]}',
-430        )
+            
    397def compute_cardinalities(input_dataframe: pd.DataFrame, pbar: Any) -> None:
+398    """Compute cardinalities of features, incrementally"""
+399
+400    global GLOBAL_CARDINALITY_STORAGE
+401    output_storage_card = defaultdict(set)
+402    for enx, column in enumerate(input_dataframe):
+403        output_storage_card[column] = set(input_dataframe[column].unique())
+404        if column not in GLOBAL_CARDINALITY_STORAGE:
+405            GLOBAL_CARDINALITY_STORAGE[column] = HyperLogLog(
+406                HYPERLL_ERROR_BOUND,
+407            )
+408
+409        for unique_value in set(input_dataframe[column].unique()):
+410            if unique_value:
+411                GLOBAL_CARDINALITY_STORAGE[column].add(
+412                    internal_hash(unique_value),
+413                )
+414        pbar.set_description(
+415            f'Computing cardinality (Hyperloglog update) {enx}/{input_dataframe.shape[1]}',
+416        )
 
    
 
 
@@ -1498,36 +1450,36 @@
    - 
    433def compute_bounds_increment(
-434    input_dataframe: pd.DataFrame, numeric_column_types: set[str],
-435) -> dict[str, Any]:
-436    all_features = input_dataframe.columns
-437    numeric_column_types = set(numeric_column_types)
-438    summary_object = {}
-439    summary_storage: Any = {}
-440    for feature in all_features:
-441        if feature in numeric_column_types:
-442            feature_vector = pd.to_numeric(
-443                input_dataframe[feature], errors='coerce',
-444            )
-445            minimum = np.min(feature_vector)
-446            maximum = np.max(feature_vector)
-447            mean = np.mean(feature_vector)
-448            summary_storage = NumericFeatureSummary(
-449                feature, minimum, maximum, mean, len(
-450                    np.unique(feature_vector),
-451                ),
-452            )
-453            summary_object[feature] = summary_storage
-454
-455        else:
-456            feature_vector = input_dataframe[feature].values
-457            summary_storage = NominalFeatureSummary(
-458                feature, len(np.unique(feature_vector)),
-459            )
-460            summary_object[feature] = summary_storage
-461
-462    return summary_object
+            
    419def compute_bounds_increment(
+420    input_dataframe: pd.DataFrame, numeric_column_types: set[str],
+421) -> dict[str, Any]:
+422    all_features = input_dataframe.columns
+423    numeric_column_types = set(numeric_column_types)
+424    summary_object = {}
+425    summary_storage: Any = {}
+426    for feature in all_features:
+427        if feature in numeric_column_types:
+428            feature_vector = pd.to_numeric(
+429                input_dataframe[feature], errors='coerce',
+430            )
+431            minimum = np.min(feature_vector)
+432            maximum = np.max(feature_vector)
+433            mean = np.mean(feature_vector)
+434            summary_storage = NumericFeatureSummary(
+435                feature, minimum, maximum, mean, len(
+436                    np.unique(feature_vector),
+437                ),
+438            )
+439            summary_object[feature] = summary_storage
+440
+441        else:
+442            feature_vector = input_dataframe[feature].values
+443            summary_storage = NominalFeatureSummary(
+444                feature, len(np.unique(feature_vector)),
+445            )
+446            summary_object[feature] = summary_storage
+447
+448    return summary_object
 
    
 
 
@@ -1545,96 +1497,96 @@
    - 
    465def compute_batch_ranking(
-466    line_tmp_storage: list[list[Any]],
-467    numeric_column_types: set[str],
-468    args: Any,
-469    cpu_pool: Any,
-470    column_descriptions: list[str],
-471    logger: Any,
-472    pbar: Any,
-473) -> tuple[BatchRankingSummary, dict[str, Any], dict[str, set[str]], dict[str, set[str]]]:
-474    """Enrich the feature space and compute the batch importances"""
-475
-476    input_dataframe = pd.DataFrame(line_tmp_storage)
-477    input_dataframe.columns = column_descriptions
-478    pbar.set_description('Control features')
-479
-480    if args.feature_set_focus:
-481        if args.feature_set_focus == '_all_from_reference_JSON':
-482            focus_set = extract_features_from_reference_JSON(
-483                args.reference_model_JSON,
-484            )
-485
-486        else:
-487            focus_set = set(args.feature_set_focus.split(','))
-488
-489        focus_set.add(args.label_column)
-490        focus_set = {x for x in focus_set if x in input_dataframe.columns}
-491        input_dataframe = input_dataframe[focus_set]
-492
-493    if args.transformers != 'none':
-494        pbar.set_description('Adding transformations')
-495        input_dataframe = enrich_with_transformations(
-496            input_dataframe, numeric_column_types, logger, args,
-497        )
-498
-499    if args.explode_multivalue_features != 'False':
-500        pbar.set_description('Constructing new features from multivalue ones')
-501        input_dataframe = compute_expanded_multivalue_features(
-502            input_dataframe, logger, args, pbar,
-503        )
-504
-505    if args.subfeature_mapping != 'False':
-506        pbar.set_description('Constructing new (sub)features')
-507        input_dataframe = compute_subfeatures(
-508            input_dataframe, logger, args, pbar,
-509        )
-510
-511    if args.interaction_order > 1:
-512        pbar.set_description('Constructing new features')
-513        input_dataframe = compute_combined_features(
-514            input_dataframe, logger, args, pbar,
-515        )
-516
-517    # in case of 3mr we compute the score of combinations against the target
-518    if '3mr' in args.heuristic:
-519        pbar.set_description(
-520            'Constructing features for computing relations in 3mr',
-521        )
-522        input_dataframe = compute_combined_features(
-523            input_dataframe, logger, args, pbar, True,
-524        )
-525
-526    if args.include_noise_baseline_features == 'True' and args.heuristic != 'Constant':
-527        pbar.set_description('Computing baseline features')
-528        input_dataframe = include_noisy_features(input_dataframe, logger, args)
-529
-530    # Compute incremental statistic useful for data inspection/transformer generation
-531    pbar.set_description('Computing coverage')
-532    coverage_storage = compute_coverage(input_dataframe, args)
-533    feature_memory_consumption = compute_feature_memory_consumption(
-534        input_dataframe, args,
-535    )
-536    compute_cardinalities(input_dataframe, pbar)
-537
-538    if args.task == 'identify_rare_values':
-539        compute_value_counts(input_dataframe, args)
-540
-541    bounds_storage = compute_bounds_increment(
-542        input_dataframe, numeric_column_types,
-543    )
-544
-545    pbar.set_description(
-546        f'Computing ranks for {input_dataframe.shape[1]} features',
-547    )
-548
-549    return (
-550        mixed_rank_graph(input_dataframe, args, cpu_pool, pbar),
-551        bounds_storage,
-552        coverage_storage,
-553        feature_memory_consumption,
-554    )
+            
    451def compute_batch_ranking(
+452    line_tmp_storage: list[list[Any]],
+453    numeric_column_types: set[str],
+454    args: Any,
+455    cpu_pool: Any,
+456    column_descriptions: list[str],
+457    logger: Any,
+458    pbar: Any,
+459) -> tuple[BatchRankingSummary, dict[str, Any], dict[str, set[str]], dict[str, set[str]]]:
+460    """Enrich the feature space and compute the batch importances"""
+461
+462    input_dataframe = pd.DataFrame(line_tmp_storage)
+463    input_dataframe.columns = column_descriptions
+464    pbar.set_description('Control features')
+465
+466    if args.feature_set_focus:
+467        if args.feature_set_focus == '_all_from_reference_JSON':
+468            focus_set = extract_features_from_reference_JSON(
+469                args.reference_model_JSON,
+470            )
+471
+472        else:
+473            focus_set = set(args.feature_set_focus.split(','))
+474
+475        focus_set.add(args.label_column)
+476        focus_set = {x for x in focus_set if x in input_dataframe.columns}
+477        input_dataframe = input_dataframe[focus_set]
+478
+479    if args.transformers != 'none':
+480        pbar.set_description('Adding transformations')
+481        input_dataframe = enrich_with_transformations(
+482            input_dataframe, numeric_column_types, logger, args,
+483        )
+484
+485    if args.explode_multivalue_features != 'False':
+486        pbar.set_description('Constructing new features from multivalue ones')
+487        input_dataframe = compute_expanded_multivalue_features(
+488            input_dataframe, logger, args, pbar,
+489        )
+490
+491    if args.subfeature_mapping != 'False':
+492        pbar.set_description('Constructing new (sub)features')
+493        input_dataframe = compute_subfeatures(
+494            input_dataframe, logger, args, pbar,
+495        )
+496
+497    if args.interaction_order > 1:
+498        pbar.set_description('Constructing new features')
+499        input_dataframe = compute_combined_features(
+500            input_dataframe, logger, args, pbar,
+501        )
+502
+503    # in case of 3mr we compute the score of combinations against the target
+504    if '3mr' in args.heuristic:
+505        pbar.set_description(
+506            'Constructing features for computing relations in 3mr',
+507        )
+508        input_dataframe = compute_combined_features(
+509            input_dataframe, logger, args, pbar, True,
+510        )
+511
+512    if args.include_noise_baseline_features == 'True' and args.heuristic != 'Constant':
+513        pbar.set_description('Computing baseline features')
+514        input_dataframe = include_noisy_features(input_dataframe, logger, args)
+515
+516    # Compute incremental statistic useful for data inspection/transformer generation
+517    pbar.set_description('Computing coverage')
+518    coverage_storage = compute_coverage(input_dataframe, args)
+519    feature_memory_consumption = compute_feature_memory_consumption(
+520        input_dataframe, args,
+521    )
+522    compute_cardinalities(input_dataframe, pbar)
+523
+524    if args.task == 'identify_rare_values':
+525        compute_value_counts(input_dataframe, args)
+526
+527    bounds_storage = compute_bounds_increment(
+528        input_dataframe, numeric_column_types,
+529    )
+530
+531    pbar.set_description(
+532        f'Computing ranks for {input_dataframe.shape[1]} features',
+533    )
+534
+535    return (
+536        mixed_rank_graph(input_dataframe, args, cpu_pool, pbar),
+537        bounds_storage,
+538        coverage_storage,
+539        feature_memory_consumption,
+540    )
 
    
 
 
@@ -1654,19 +1606,19 @@
    - 
    557def get_num_of_instances(fname: str) -> int:
-558    """Count the number of lines in a file, fast - useful for progress logging"""
-559
-560    def _make_gen(reader):
-561        while True:
-562            b = reader(2**16)
-563            if not b:
-564                break
-565            yield b
-566
-567    with open(fname, 'rb') as f:
-568        count = sum(buf.count(b'\n') for buf in _make_gen(f.raw.read))
-569    return count
+            
    543def get_num_of_instances(fname: str) -> int:
+544    """Count the number of lines in a file, fast - useful for progress logging"""
+545
+546    def _make_gen(reader):
+547        while True:
+548            b = reader(2**16)
+549            if not b:
+550                break
+551            yield b
+552
+553    with open(fname, 'rb') as f:
+554        count = sum(buf.count(b'\n') for buf in _make_gen(f.raw.read))
+555    return count
 
    
 
 
@@ -1686,17 +1638,17 @@
    - 
    572def get_grouped_df(importances_df_list: list[tuple[str, str, float]]) -> pd.DataFrame:
-573    """A helper method that enables median-based aggregation after processing"""
-574
-575    importances_df = pd.DataFrame(importances_df_list)
-576    if len(importances_df) == 0:
-577        return None
-578    importances_df.columns = ['FeatureA', 'FeatureB', 'Score']
-579    grouped = importances_df.groupby(
-580        ['FeatureA', 'FeatureB'],
-581    ).median().reset_index()
-582    return grouped
+            
    558def get_grouped_df(importances_df_list: list[tuple[str, str, float]]) -> pd.DataFrame:
+559    """A helper method that enables median-based aggregation after processing"""
+560
+561    importances_df = pd.DataFrame(importances_df_list)
+562    if len(importances_df) == 0:
+563        return None
+564    importances_df.columns = ['FeatureA', 'FeatureB', 'Score']
+565    grouped = importances_df.groupby(
+566        ['FeatureA', 'FeatureB'],
+567    ).median().reset_index()
+568    return grouped
 
    
 
 
@@ -1716,12 +1668,12 @@
    - 
    585def checkpoint_importances_df(importances_batch: list[tuple[str, str, float]]) -> None:
-586    """A helper which stores intermediary state - useful for longer runs"""
-587
-588    gdf = get_grouped_df(importances_batch)
-589    if gdf is not None:
-590        gdf.to_csv('ranking_checkpoint_tmp.tsv', sep='\t')
+            
    571def checkpoint_importances_df(importances_batch: list[tuple[str, str, float]]) -> None:
+572    """A helper which stores intermediary state - useful for longer runs"""
+573
+574    gdf = get_grouped_df(importances_batch)
+575    if gdf is not None:
+576        gdf.to_csv('ranking_checkpoint_tmp.tsv', sep='\t')
 
    
 
 
@@ -1741,147 +1693,147 @@
    - 
    593def estimate_importances_minibatches(
-594    input_file: str,
-595    column_descriptions: list,
-596    fw_col_mapping: dict[str, str],
-597    numeric_column_types: set,
-598    batch_size: int = 100000,
-599    args: Any = None,
-600    data_encoding: str = 'utf-8',
-601    cpu_pool: Any = None,
-602    delimiter: str = '\t',
-603    feature_construction_mode: bool = False,
-604    logger: Any = None,
-605) -> tuple[list[dict[str, Any]], Any, dict[Any, Any], list[dict[str, Any]], list[dict[str, set[str]]], defaultdict[str, list[set[str]]], dict[str, Any]]:
-606    """Interaction score estimator - suitable for example for csv-like input data types.
-607    This type of data is normally a single large csv, meaning that minibatch processing needs to
-608    happen during incremental handling of the file (that"s not the case for pre-separated ob data)
-609    """
-610
-611    invalid_line_queue: Any = deque([], maxlen=2**5)
+            
    579def estimate_importances_minibatches(
+580    input_file: str,
+581    column_descriptions: list,
+582    fw_col_mapping: dict[str, str],
+583    numeric_column_types: set,
+584    batch_size: int = 100000,
+585    args: Any = None,
+586    data_encoding: str = 'utf-8',
+587    cpu_pool: Any = None,
+588    delimiter: str = '\t',
+589    feature_construction_mode: bool = False,
+590    logger: Any = None,
+591) -> tuple[list[dict[str, Any]], Any, dict[Any, Any], list[dict[str, Any]], list[dict[str, set[str]]], defaultdict[str, list[set[str]]], dict[str, Any]]:
+592    """Interaction score estimator - suitable for example for csv-like input data types.
+593    This type of data is normally a single large csv, meaning that minibatch processing needs to
+594    happen during incremental handling of the file (that"s not the case for pre-separated ob data)
+595    """
+596
+597    invalid_line_queue: Any = deque([], maxlen=2**5)
+598
+599    invalid_lines = 0
+600    line_counter = 0
+601
+602    importances_df: list[Any] = []
+603    line_tmp_storage = []
+604    bounds_storage_batch = []
+605    memory_storage_batch = []
+606    step_timing_checkpoints = []
+607
+608    local_coverage_object = defaultdict(list)
+609    local_pbar = tqdm.tqdm(
+610        total=get_num_of_instances(input_file) - 1, position=0,
+611    )
 612
-613    invalid_lines = 0
-614    line_counter = 0
-615
-616    importances_df: list[Any] = []
-617    line_tmp_storage = []
-618    bounds_storage_batch = []
-619    memory_storage_batch = []
-620    step_timing_checkpoints = []
-621
-622    local_coverage_object = defaultdict(list)
-623    local_pbar = tqdm.tqdm(
-624        total=get_num_of_instances(input_file) - 1, position=0,
-625    )
-626
-627    file_name, file_extension = os.path.splitext(input_file)
-628
-629    if file_extension == '.gz':
-630        file_stream = gzip.open(input_file, 'rt', encoding=data_encoding)
-631
-632    else:
-633        file_stream = open(input_file, encoding=data_encoding)
+613    file_name, file_extension = os.path.splitext(input_file)
+614
+615    if file_extension == '.gz':
+616        file_stream = gzip.open(input_file, 'rt', encoding=data_encoding)
+617
+618    else:
+619        file_stream = open(input_file, encoding=data_encoding)
+620
+621    file_stream.readline()
+622
+623    local_pbar.set_description('Starting ranking computation')
+624    for line in file_stream:
+625        line_counter += 1
+626        local_pbar.update(1)
+627
+628        if line_counter % args.subsampling != 0:
+629            continue
+630
+631        parsed_line = generic_line_parser(
+632            line, delimiter, args, fw_col_mapping, column_descriptions,
+633        )
 634
-635    file_stream.readline()
-636
-637    local_pbar.set_description('Starting ranking computation')
-638    for line in file_stream:
-639        line_counter += 1
-640        local_pbar.update(1)
+635        if len(parsed_line) == len(column_descriptions):
+636            line_tmp_storage.append(parsed_line)
+637
+638        else:
+639            invalid_line_queue.appendleft(str(parsed_line))
+640            invalid_lines += 1
 641
-642        if line_counter % args.subsampling != 0:
-643            continue
+642        # Batches need to be processed on-the-fly
+643        if len(line_tmp_storage) >= args.minibatch_size:
 644
-645        parsed_line = generic_line_parser(
-646            line, delimiter, args, fw_col_mapping, column_descriptions,
-647        )
-648
-649        if len(parsed_line) == len(column_descriptions):
-650            line_tmp_storage.append(parsed_line)
-651
-652        else:
-653            invalid_line_queue.appendleft(str(parsed_line))
-654            invalid_lines += 1
-655
-656        # Batches need to be processed on-the-fly
-657        if len(line_tmp_storage) >= args.minibatch_size:
-658
-659            importances_batch, bounds_storage, coverage_storage, memory_storage = compute_batch_ranking(
-660                line_tmp_storage,
-661                numeric_column_types,
-662                args,
-663                cpu_pool,
-664                column_descriptions,
-665                logger,
-666                local_pbar,
-667            )
-668
-669            bounds_storage_batch.append(bounds_storage)
-670            memory_storage_batch.append(memory_storage)
-671            for k, v in coverage_storage.items():
-672                local_coverage_object[k].append(v)
-673
-674            del coverage_storage
-675
-676            line_tmp_storage = []
-677            step_timing_checkpoints.append(importances_batch.step_times)
-678            importances_df += importances_batch.triplet_scores
-679
-680            if args.heuristic != 'Constant':
-681                local_pbar.set_description('Creating checkpoint')
-682                checkpoint_importances_df(importances_df)
-683
-684    file_stream.close()
-685
-686    local_pbar.set_description('Parsing the remainder')
-687    if invalid_lines > 0:
-688        logger.info(
-689            f"Detected {invalid_lines} invalid lines. If this number is very high, it's possible your header is off - re-check your data/attribute-feature mappings please!",
-690        )
-691
-692        invalid_lines_log = '\n INVALID_LINE ====> '.join(
-693            list(invalid_line_queue)[0:5],
-694        )
-695        logger.info(
-696            f'5 samples of invalid lines are printed below\n {invalid_lines_log}',
+645            importances_batch, bounds_storage, coverage_storage, memory_storage = compute_batch_ranking(
+646                line_tmp_storage,
+647                numeric_column_types,
+648                args,
+649                cpu_pool,
+650                column_descriptions,
+651                logger,
+652                local_pbar,
+653            )
+654
+655            bounds_storage_batch.append(bounds_storage)
+656            memory_storage_batch.append(memory_storage)
+657            for k, v in coverage_storage.items():
+658                local_coverage_object[k].append(v)
+659
+660            del coverage_storage
+661
+662            line_tmp_storage = []
+663            step_timing_checkpoints.append(importances_batch.step_times)
+664            importances_df += importances_batch.triplet_scores
+665
+666            if args.heuristic != 'Constant':
+667                local_pbar.set_description('Creating checkpoint')
+668                checkpoint_importances_df(importances_df)
+669
+670    file_stream.close()
+671
+672    local_pbar.set_description('Parsing the remainder')
+673    if invalid_lines > 0:
+674        logger.info(
+675            f"Detected {invalid_lines} invalid lines. If this number is very high, it's possible your header is off - re-check your data/attribute-feature mappings please!",
+676        )
+677
+678        invalid_lines_log = '\n INVALID_LINE ====> '.join(
+679            list(invalid_line_queue)[0:5],
+680        )
+681        logger.info(
+682            f'5 samples of invalid lines are printed below\n {invalid_lines_log}',
+683        )
+684
+685    remaining_batch_size = len(line_tmp_storage)
+686
+687    if remaining_batch_size > 2**10:
+688        line_tmp_storage = line_tmp_storage[: args.minibatch_size]
+689        importances_batch, bounds_storage, coverage_storage, _ = compute_batch_ranking(
+690            line_tmp_storage,
+691            numeric_column_types,
+692            args,
+693            cpu_pool,
+694            column_descriptions,
+695            logger,
+696            local_pbar,
 697        )
 698
-699    remaining_batch_size = len(line_tmp_storage)
-700
-701    if remaining_batch_size > 2**10:
-702        line_tmp_storage = line_tmp_storage[: args.minibatch_size]
-703        importances_batch, bounds_storage, coverage_storage, _ = compute_batch_ranking(
-704            line_tmp_storage,
-705            numeric_column_types,
-706            args,
-707            cpu_pool,
-708            column_descriptions,
-709            logger,
-710            local_pbar,
-711        )
-712
-713        for k, v in coverage_storage.items():
-714            local_coverage_object[k].append(v)
-715
-716        step_timing_checkpoints.append(importances_batch.step_times)
-717        importances_df += importances_batch.triplet_scores
-718        bounds_storage = dict()
-719        bounds_storage_batch.append(bounds_storage)
-720        checkpoint_importances_df(importances_df)
-721
-722    local_pbar.set_description('Wrapping up')
-723    local_pbar.close()
-724
-725    return (
-726        step_timing_checkpoints,
-727        get_grouped_df(importances_df),
-728        GLOBAL_CARDINALITY_STORAGE,
-729        bounds_storage_batch,
-730        memory_storage_batch,
-731        local_coverage_object,
-732        GLOBAL_RARE_VALUE_STORAGE,
-733    )
+699        for k, v in coverage_storage.items():
+700            local_coverage_object[k].append(v)
+701
+702        step_timing_checkpoints.append(importances_batch.step_times)
+703        importances_df += importances_batch.triplet_scores
+704        bounds_storage = dict()
+705        bounds_storage_batch.append(bounds_storage)
+706        checkpoint_importances_df(importances_df)
+707
+708    local_pbar.set_description('Wrapping up')
+709    local_pbar.close()
+710
+711    return (
+712        step_timing_checkpoints,
+713        get_grouped_df(importances_df),
+714        GLOBAL_CARDINALITY_STORAGE,
+715        bounds_storage_batch,
+716        memory_storage_batch,
+717        local_coverage_object,
+718        GLOBAL_RARE_VALUE_STORAGE,
+719    )
 
    
 
 
diff --git a/docs/outrank/task_selftest.html b/docs/outrank/task_selftest.html
index f4ab0cf..1bcb254 100644
--- a/docs/outrank/task_selftest.html
+++ b/docs/outrank/task_selftest.html
@@ -90,7 +90,7 @@ 
    
 31    logger.info("Verifying output's properties ..")
 32    assert dfx.shape[0] == 201
 33    assert dfx.shape[1] == 3
-34    assert dfx['FeatureA'].values.tolist().pop() == 'label-(81; 100)'
+34    assert dfx['FeatureA'].values.tolist().pop() == 'label-(81; 100)' or dfx['FeatureB'].values.tolist().pop() == 'label-(81; 100)'
 35
 36    to_remove = ['ranking_outputs', 'test_data_synthetic']
 37    for path in to_remove:
@@ -141,7 +141,7 @@ 
    
 32    logger.info("Verifying output's properties ..")
 33    assert dfx.shape[0] == 201
 34    assert dfx.shape[1] == 3
-35    assert dfx['FeatureA'].values.tolist().pop() == 'label-(81; 100)'
+35    assert dfx['FeatureA'].values.tolist().pop() == 'label-(81; 100)' or dfx['FeatureB'].values.tolist().pop() == 'label-(81; 100)'
 36
 37    to_remove = ['ranking_outputs', 'test_data_synthetic']
 38    for path in to_remove:
diff --git a/docs/search.js b/docs/search.js
index f8fa1ad..244a574 100644
--- a/docs/search.js
+++ b/docs/search.js
@@ -1,6 +1,6 @@
 window.pdocSearch = (function(){
 /** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();oWelcome to OutRank's documentation!
    \n\n
    All functions/methods can be searched-for (search bar on the left).
    \n\n
    This tool enables fast screening of feature-feature interactions. Its purpose is to give the user fast insight into potential redundancies/anomalies in the data.\nIt is implemented to operate in _mini batches_, it traverses the raw data incrementally, refining the rankings as it goes along. The core operation, interaction ranking, outputs triplets which look as follows:
    \n\n
    featureA    featureB    0.512\nfeatureA    featureC    0.125\n
    \n\n
    Setup
    \n\n
    \n
    pip install outrank\n
    \n
    \n\n
    and test a minimal cycle with
    \n\n
    \n
    outrank --task selftest\n
    \n
    \n\n
    if this passes, you can be pretty certain OutRank will perform as intended. OutRank's primary use case is as a CLI tool, begin exploring with
    \n\n
    \n
    outrank --help\n
    \n
    \n\n
    Example use cases
    \n\n
      \n
    • A minimal showcase of performing feature ranking on a generic CSV is demonstrated with this example.
      • \n
    • More examples demonstrating OutRank's capabilities are also available.
      • \n
    \n"}, "outrank.algorithms": {"fullname": "outrank.algorithms", "modulename": "outrank.algorithms", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking": {"fullname": "outrank.algorithms.feature_ranking", "modulename": "outrank.algorithms.feature_ranking", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "numba_unique", "kind": "function", "doc": "
    Identify unique elements in an array, fast
    \n", "signature": "(a):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "compute_conditional_entropy", "kind": "function", "doc": "
    \n", "signature": "(Y_classes, class_values, class_var_shape, initial_prob):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "compute_entropies", "kind": "function", "doc": "
    Core entropy computation function
    \n", "signature": "(X, Y, all_events, f_values, f_value_counts, cardinality_correction):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "mutual_info_estimator_numba", "kind": "function", "doc": "
    Core estimator logic. Compute unique elements, subset if required
    \n", "signature": "(Y, X, approximation_factor=1, cardinality_correction=False):", "funcdef": "def"}, "outrank.algorithms.importance_estimator": {"fullname": "outrank.algorithms.importance_estimator", "modulename": "outrank.algorithms.importance_estimator", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.importance_estimator.sklearn_MI": {"fullname": "outrank.algorithms.importance_estimator.sklearn_MI", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_MI", "kind": "function", "doc": "
    \n", "signature": "(vector_first: Any, vector_second: Any) -> float:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"fullname": "outrank.algorithms.importance_estimator.sklearn_surrogate", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_surrogate", "kind": "function", "doc": "
    \n", "signature": "(vector_first: Any, vector_second: Any, surrogate_model: str) -> float:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.numba_mi": {"fullname": "outrank.algorithms.importance_estimator.numba_mi", "modulename": "outrank.algorithms.importance_estimator", "qualname": "numba_mi", "kind": "function", "doc": "
    \n", "signature": "(vector_first, vector_second, heuristic):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"fullname": "outrank.algorithms.importance_estimator.sklearn_mi_adj", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_mi_adj", "kind": "function", "doc": "
    \n", "signature": "(vector_first, vector_second):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"fullname": "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise", "modulename": "outrank.algorithms.importance_estimator", "qualname": "get_importances_estimate_pairwise", "kind": "function", "doc": "
    A method for parallel importances estimation. As interaction scoring is independent, individual scores can be computed in parallel.
    \n", "signature": "(combination, args, tmp_df):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"fullname": "outrank.algorithms.importance_estimator.rank_features_3MR", "modulename": "outrank.algorithms.importance_estimator", "qualname": "rank_features_3MR", "kind": "function", "doc": "
    \n", "signature": "(\trelevance_dict: dict[str, float],\tredundancy_dict: dict[tuple[typing.Any, typing.Any], typing.Any],\trelational_dict: dict[tuple[typing.Any, typing.Any], typing.Any],\tstrategy: str = 'median',\talpha: float = 1,\tbeta: float = 1) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"fullname": "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic", "modulename": "outrank.algorithms.importance_estimator", "qualname": "get_importances_estimate_nonmyopic", "kind": "function", "doc": "
    \n", "signature": "(args: Any, tmp_df: pandas.core.frame.DataFrame):", "funcdef": "def"}, "outrank.algorithms.sketches": {"fullname": "outrank.algorithms.sketches", "modulename": "outrank.algorithms.sketches", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "kind": "module", "doc": "
    This module implements probabilistic data structure which is able to calculate the cardinality of large multisets in a single pass using little auxiliary memory
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache", "kind": "class", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.__init__", "kind": "function", "doc": "
    \n", "signature": "(error_rate=0.005)"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.p", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.m", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.warmup_set", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.warmup_size", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.width", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.hll_flag", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.add", "kind": "function", "doc": "
    \n", "signature": "(self, value):", "funcdef": "def"}, "outrank.algorithms.synthetic_data_generators": {"fullname": "outrank.algorithms.synthetic_data_generators", "modulename": "outrank.algorithms.synthetic_data_generators", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"fullname": "outrank.algorithms.synthetic_data_generators.generator_naive", "modulename": "outrank.algorithms.synthetic_data_generators.generator_naive", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"fullname": "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix", "modulename": "outrank.algorithms.synthetic_data_generators.generator_naive", "qualname": "generate_random_matrix", "kind": "function", "doc": "
    \n", "signature": "(num_features=100, size=20000):", "funcdef": "def"}, "outrank.core_ranking": {"fullname": "outrank.core_ranking", "modulename": "outrank.core_ranking", "kind": "module", "doc": "
    \n"}, "outrank.core_ranking.logger": {"fullname": "outrank.core_ranking.logger", "modulename": "outrank.core_ranking", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"fullname": "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE", "modulename": "outrank.core_ranking", "qualname": "GLOBAL_CARDINALITY_STORAGE", "kind": "variable", "doc": "
    \n", "annotation": ": dict[typing.Any, typing.Any]", "default_value": "{}"}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"fullname": "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE", "modulename": "outrank.core_ranking", "qualname": "GLOBAL_RARE_VALUE_STORAGE", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, typing.Any]", "default_value": "Counter()"}, "outrank.core_ranking.IGNORED_VALUES": {"fullname": "outrank.core_ranking.IGNORED_VALUES", "modulename": "outrank.core_ranking", "qualname": "IGNORED_VALUES", "kind": "variable", "doc": "
    \n", "default_value": "set()"}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"fullname": "outrank.core_ranking.HYPERLL_ERROR_BOUND", "modulename": "outrank.core_ranking", "qualname": "HYPERLL_ERROR_BOUND", "kind": "variable", "doc": "
    \n", "default_value": "0.02"}, "outrank.core_ranking.encode_int_column": {"fullname": "outrank.core_ranking.encode_int_column", "modulename": "outrank.core_ranking", "qualname": "encode_int_column", "kind": "function", "doc": "
    Encode column values as categoric (at a batch level!)
    \n", "signature": "(input_tuple: tuple[str, typing.Any]) -> tuple[typing.Any, list[int]]:", "funcdef": "def"}, "outrank.core_ranking.mixed_rank_graph": {"fullname": "outrank.core_ranking.mixed_rank_graph", "modulename": "outrank.core_ranking", "qualname": "mixed_rank_graph", "kind": "function", "doc": "
    Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any,\tcpu_pool: Any,\tpbar: Any) -> outrank.core_utils.BatchRankingSummary:", "funcdef": "def"}, "outrank.core_ranking.enrich_with_transformations": {"fullname": "outrank.core_ranking.enrich_with_transformations", "modulename": "outrank.core_ranking", "qualname": "enrich_with_transformations", "kind": "function", "doc": "
    Construct a collection of new features based on pre-defined transformations/rules
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tnum_col_types: set[str],\tlogger: Any,\targs: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_combined_features": {"fullname": "outrank.core_ranking.compute_combined_features", "modulename": "outrank.core_ranking", "qualname": "compute_combined_features", "kind": "function", "doc": "
    Compute higher order features via xxhash-based trick.
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any,\tis_3mr: bool = False) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_expanded_multivalue_features": {"fullname": "outrank.core_ranking.compute_expanded_multivalue_features", "modulename": "outrank.core_ranking", "qualname": "compute_expanded_multivalue_features", "kind": "function", "doc": "
    Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value \"a,b,c\" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice.
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_subfeatures": {"fullname": "outrank.core_ranking.compute_subfeatures", "modulename": "outrank.core_ranking", "qualname": "compute_subfeatures", "kind": "function", "doc": "
    Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.\n->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.\n<->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.include_noisy_features": {"fullname": "outrank.core_ranking.include_noisy_features", "modulename": "outrank.core_ranking", "qualname": "include_noisy_features", "kind": "function", "doc": "
    Add randomized features that serve as a sanity check
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_coverage": {"fullname": "outrank.core_ranking.compute_coverage", "modulename": "outrank.core_ranking", "qualname": "compute_coverage", "kind": "function", "doc": "
    Compute coverage of features, incrementally
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any) -> dict[str, set[str]]:", "funcdef": "def"}, "outrank.core_ranking.compute_feature_memory_consumption": {"fullname": "outrank.core_ranking.compute_feature_memory_consumption", "modulename": "outrank.core_ranking", "qualname": "compute_feature_memory_consumption", "kind": "function", "doc": "
    An approximation of how much feature take up
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any) -> dict[str, set[str]]:", "funcdef": "def"}, "outrank.core_ranking.compute_value_counts": {"fullname": "outrank.core_ranking.compute_value_counts", "modulename": "outrank.core_ranking", "qualname": "compute_value_counts", "kind": "function", "doc": "
    Update the count structure
    \n", "signature": "(input_dataframe: pandas.core.frame.DataFrame, args: Any):", "funcdef": "def"}, "outrank.core_ranking.compute_cardinalities": {"fullname": "outrank.core_ranking.compute_cardinalities", "modulename": "outrank.core_ranking", "qualname": "compute_cardinalities", "kind": "function", "doc": "
    Compute cardinalities of features, incrementally
    \n", "signature": "(input_dataframe: pandas.core.frame.DataFrame, pbar: Any) -> None:", "funcdef": "def"}, "outrank.core_ranking.compute_bounds_increment": {"fullname": "outrank.core_ranking.compute_bounds_increment", "modulename": "outrank.core_ranking", "qualname": "compute_bounds_increment", "kind": "function", "doc": "
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tnumeric_column_types: set[str]) -> dict[str, typing.Any]:", "funcdef": "def"}, "outrank.core_ranking.compute_batch_ranking": {"fullname": "outrank.core_ranking.compute_batch_ranking", "modulename": "outrank.core_ranking", "qualname": "compute_batch_ranking", "kind": "function", "doc": "
    Enrich the feature space and compute the batch importances
    \n", "signature": "(\tline_tmp_storage: list[list[typing.Any]],\tnumeric_column_types: set[str],\targs: Any,\tcpu_pool: Any,\tcolumn_descriptions: list[str],\tlogger: Any,\tpbar: Any) -> tuple[outrank.core_utils.BatchRankingSummary, dict[str, typing.Any], dict[str, set[str]], dict[str, set[str]]]:", "funcdef": "def"}, "outrank.core_ranking.get_num_of_instances": {"fullname": "outrank.core_ranking.get_num_of_instances", "modulename": "outrank.core_ranking", "qualname": "get_num_of_instances", "kind": "function", "doc": "
    Count the number of lines in a file, fast - useful for progress logging
    \n", "signature": "(fname: str) -> int:", "funcdef": "def"}, "outrank.core_ranking.get_grouped_df": {"fullname": "outrank.core_ranking.get_grouped_df", "modulename": "outrank.core_ranking", "qualname": "get_grouped_df", "kind": "function", "doc": "
    A helper method that enables median-based aggregation after processing
    \n", "signature": "(\timportances_df_list: list[tuple[str, str, float]]) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.checkpoint_importances_df": {"fullname": "outrank.core_ranking.checkpoint_importances_df", "modulename": "outrank.core_ranking", "qualname": "checkpoint_importances_df", "kind": "function", "doc": "
    A helper which stores intermediary state - useful for longer runs
    \n", "signature": "(importances_batch: list[tuple[str, str, float]]) -> None:", "funcdef": "def"}, "outrank.core_ranking.estimate_importances_minibatches": {"fullname": "outrank.core_ranking.estimate_importances_minibatches", "modulename": "outrank.core_ranking", "qualname": "estimate_importances_minibatches", "kind": "function", "doc": "
    Interaction score estimator - suitable for example for csv-like input data types.\nThis type of data is normally a single large csv, meaning that minibatch processing needs to\nhappen during incremental handling of the file (that\"s not the case for pre-separated ob data)
    \n", "signature": "(\tinput_file: str,\tcolumn_descriptions: list,\tfw_col_mapping: dict[str, str],\tnumeric_column_types: set,\tbatch_size: int = 100000,\targs: Any = None,\tdata_encoding: str = 'utf-8',\tcpu_pool: Any = None,\tdelimiter: str = '\\t',\tfeature_construction_mode: bool = False,\tlogger: Any = None) -> tuple[list[dict[str, typing.Any]], typing.Any, dict[typing.Any, typing.Any], list[dict[str, typing.Any]], list[dict[str, set[str]]], collections.defaultdict[str, list[set[str]]], dict[str, typing.Any]]:", "funcdef": "def"}, "outrank.core_selftest": {"fullname": "outrank.core_selftest", "modulename": "outrank.core_selftest", "kind": "module", "doc": "
    \n"}, "outrank.core_utils": {"fullname": "outrank.core_utils", "modulename": "outrank.core_utils", "kind": "module", "doc": "
    \n"}, "outrank.core_utils.pro_tips": {"fullname": "outrank.core_utils.pro_tips", "modulename": "outrank.core_utils", "qualname": "pro_tips", "kind": "variable", "doc": "
    \n", "default_value": "['OutRank can construct subfeatures; features based on subspaces. Example command argument is: --subfeature_mapping "feature_a->feature_b;feature_c<->feature_d;feature_c<->feature_e"', 'Heuristic MI-numba-randomized seems like the best of both worlds! (speed + performance).', 'Heuristic surrogate-lr performs cross-validation (internally), keep that in mind!', 'Consider running OutRank on a smaller data sample first, might be enough (--subsampling = a lot).', 'There are two types of combinations supported; unsupervised pairwise ranking (redundancies- --target_ranking_only=False), and supervised combinations - (--interaction_order > 1)', 'Visualization part also includes clustering - this might be very insightful!', 'By default OutRank includes feature cardinality and coverage in feature names (card; cov)', 'Intermediary checkpoints (tmp_checkpoint.tsv) might already give you insights during longer runs.', 'In theory, you can rank redundancies of combined features (--interaction_order AND --target_ranking_only=False).', 'Give it as many threads as physically possible (--num_threads).', 'You can speed up ranking by diminishing feature buffer size (--combination_number_upper_bound determines how many ranking computations per batch will be considered). This, and --subsampling are very powerful together.', 'Want to rank feature transformations, but not sure which ones to choose? --transformers=default should serve as a solid baseline (common DS transformations included).', 'Your target can be any feature! (explaining one feature with others)', 'OutRank uses HyperLogLog for cardinality estimation - this is also a potential usecase (understanding cardinalities across different data sets).', 'Each feature is named as featureName(cardinality, coverage in percents) in the final files.', 'You can generate candidate feature transformation ranges (fw) by using --task=feature_summary_transformers.']"}, "outrank.core_utils.write_json_dump_to_file": {"fullname": "outrank.core_utils.write_json_dump_to_file", "modulename": "outrank.core_utils", "qualname": "write_json_dump_to_file", "kind": "function", "doc": "
    \n", "signature": "(args: Any, config_name: str) -> None:", "funcdef": "def"}, "outrank.core_utils.internal_hash": {"fullname": "outrank.core_utils.internal_hash", "modulename": "outrank.core_utils", "qualname": "internal_hash", "kind": "function", "doc": "
    A generic internal hash used throughout ranking procedure - let's hardcode seed here for sure
    \n", "signature": "(input_obj: str) -> str:", "funcdef": "def"}, "outrank.core_utils.DatasetInformationStorage": {"fullname": "outrank.core_utils.DatasetInformationStorage", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage", "kind": "class", "doc": "
    A generic class for holding properties of a given type of dataset
    \n"}, "outrank.core_utils.DatasetInformationStorage.__init__": {"fullname": "outrank.core_utils.DatasetInformationStorage.__init__", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tdata_path: str,\tcolumn_names: list[str],\tcolumn_types: set[str],\tcol_delimiter: str | None,\tencoding: str,\tfw_map: dict[str, str] | None)"}, "outrank.core_utils.DatasetInformationStorage.data_path": {"fullname": "outrank.core_utils.DatasetInformationStorage.data_path", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.data_path", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.DatasetInformationStorage.column_names": {"fullname": "outrank.core_utils.DatasetInformationStorage.column_names", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.column_names", "kind": "variable", "doc": "
    \n", "annotation": ": list[str]"}, "outrank.core_utils.DatasetInformationStorage.column_types": {"fullname": "outrank.core_utils.DatasetInformationStorage.column_types", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.column_types", "kind": "variable", "doc": "
    \n", "annotation": ": set[str]"}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"fullname": "outrank.core_utils.DatasetInformationStorage.col_delimiter", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.col_delimiter", "kind": "variable", "doc": "
    \n", "annotation": ": str | None"}, "outrank.core_utils.DatasetInformationStorage.encoding": {"fullname": "outrank.core_utils.DatasetInformationStorage.encoding", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.encoding", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"fullname": "outrank.core_utils.DatasetInformationStorage.fw_map", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.fw_map", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, str] | None"}, "outrank.core_utils.NumericFeatureSummary": {"fullname": "outrank.core_utils.NumericFeatureSummary", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary", "kind": "class", "doc": "
    A generic class storing numeric feature statistics
    \n"}, "outrank.core_utils.NumericFeatureSummary.__init__": {"fullname": "outrank.core_utils.NumericFeatureSummary.__init__", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tfeature_name: str,\tminimum: float,\tmaximum: float,\tmedian: float,\tnum_unique: int)"}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"fullname": "outrank.core_utils.NumericFeatureSummary.feature_name", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.feature_name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.NumericFeatureSummary.minimum": {"fullname": "outrank.core_utils.NumericFeatureSummary.minimum", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.minimum", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.maximum": {"fullname": "outrank.core_utils.NumericFeatureSummary.maximum", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.maximum", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.median": {"fullname": "outrank.core_utils.NumericFeatureSummary.median", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.median", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"fullname": "outrank.core_utils.NumericFeatureSummary.num_unique", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.num_unique", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "outrank.core_utils.NominalFeatureSummary": {"fullname": "outrank.core_utils.NominalFeatureSummary", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary", "kind": "class", "doc": "
    A generic class storing numeric feature statistics
    \n"}, "outrank.core_utils.NominalFeatureSummary.__init__": {"fullname": "outrank.core_utils.NominalFeatureSummary.__init__", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(feature_name: str, num_unique: int)"}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"fullname": "outrank.core_utils.NominalFeatureSummary.feature_name", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.feature_name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"fullname": "outrank.core_utils.NominalFeatureSummary.num_unique", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.num_unique", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "outrank.core_utils.BatchRankingSummary": {"fullname": "outrank.core_utils.BatchRankingSummary", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary", "kind": "class", "doc": "
    A generic class representing batched ranking results
    \n"}, "outrank.core_utils.BatchRankingSummary.__init__": {"fullname": "outrank.core_utils.BatchRankingSummary.__init__", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(\ttriplet_scores: list[tuple[str, str, float]],\tstep_times: dict[str, typing.Any])"}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"fullname": "outrank.core_utils.BatchRankingSummary.triplet_scores", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.triplet_scores", "kind": "variable", "doc": "
    \n", "annotation": ": list[tuple[str, str, float]]"}, "outrank.core_utils.BatchRankingSummary.step_times": {"fullname": "outrank.core_utils.BatchRankingSummary.step_times", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.step_times", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, typing.Any]"}, "outrank.core_utils.display_random_tip": {"fullname": "outrank.core_utils.display_random_tip", "modulename": "outrank.core_utils", "qualname": "display_random_tip", "kind": "function", "doc": "
    \n", "signature": "() -> None:", "funcdef": "def"}, "outrank.core_utils.get_dataset_info": {"fullname": "outrank.core_utils.get_dataset_info", "modulename": "outrank.core_utils", "qualname": "get_dataset_info", "kind": "function", "doc": "
    \n", "signature": "(args: Any):", "funcdef": "def"}, "outrank.core_utils.display_tool_name": {"fullname": "outrank.core_utils.display_tool_name", "modulename": "outrank.core_utils", "qualname": "display_tool_name", "kind": "function", "doc": "
    \n", "signature": "() -> None:", "funcdef": "def"}, "outrank.core_utils.parse_ob_line": {"fullname": "outrank.core_utils.parse_ob_line", "modulename": "outrank.core_utils", "qualname": "parse_ob_line", "kind": "function", "doc": "
    Outbrain line parsing - generic TSVs
    \n", "signature": "(line_string: str, delimiter: str = '\\t', args: Any = None) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_line_vw": {"fullname": "outrank.core_utils.parse_ob_line_vw", "modulename": "outrank.core_utils", "qualname": "parse_ob_line_vw", "kind": "function", "doc": "
    Parse a sparse vw line into a pandas df with pre-defined namespace
    \n", "signature": "(\tline_string: str,\tdelimiter: str,\targs: Any = None,\tfw_col_mapping=None,\ttable_header=None,\tinclude_namespace_info=False) -> list[str | None]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_csv_line": {"fullname": "outrank.core_utils.parse_ob_csv_line", "modulename": "outrank.core_utils", "qualname": "parse_ob_csv_line", "kind": "function", "doc": "
    Data can have commas within JSON field dumps
    \n", "signature": "(line_string: str, delimiter: str = ',', args: Any = None) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.generic_line_parser": {"fullname": "outrank.core_utils.generic_line_parser", "modulename": "outrank.core_utils", "qualname": "generic_line_parser", "kind": "function", "doc": "
    A generic method aimed to parse data from different sources.
    \n", "signature": "(\tline_string: str,\tdelimiter: str,\targs: Any = None,\tfw_col_mapping: Any = None,\ttable_header: Any = None) -> list[typing.Any]:", "funcdef": "def"}, "outrank.core_utils.read_reference_json": {"fullname": "outrank.core_utils.read_reference_json", "modulename": "outrank.core_utils", "qualname": "read_reference_json", "kind": "function", "doc": "
    A helper method for reading a JSON
    \n", "signature": "(json_path) -> dict[str, dict]:", "funcdef": "def"}, "outrank.core_utils.parse_namespace": {"fullname": "outrank.core_utils.parse_namespace", "modulename": "outrank.core_utils", "qualname": "parse_namespace", "kind": "function", "doc": "
    Parse the feature namespace for type awareness
    \n", "signature": "(namespace_path: str) -> tuple[set[str], dict[str, str]]:", "funcdef": "def"}, "outrank.core_utils.read_column_names": {"fullname": "outrank.core_utils.read_column_names", "modulename": "outrank.core_utils", "qualname": "read_column_names", "kind": "function", "doc": "
    Read the col. header
    \n", "signature": "(mapping_file: str) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_vw_feature_information": {"fullname": "outrank.core_utils.parse_ob_vw_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_vw_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_ob_raw_feature_information": {"fullname": "outrank.core_utils.parse_ob_raw_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_raw_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_ob_feature_information": {"fullname": "outrank.core_utils.parse_ob_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_csv_with_description_information": {"fullname": "outrank.core_utils.parse_csv_with_description_information", "modulename": "outrank.core_utils", "qualname": "parse_csv_with_description_information", "kind": "function", "doc": "
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_csv_raw": {"fullname": "outrank.core_utils.parse_csv_raw", "modulename": "outrank.core_utils", "qualname": "parse_csv_raw", "kind": "function", "doc": "
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.extract_features_from_reference_JSON": {"fullname": "outrank.core_utils.extract_features_from_reference_JSON", "modulename": "outrank.core_utils", "qualname": "extract_features_from_reference_JSON", "kind": "function", "doc": "
    Given a model's JSON, extract unique features
    \n", "signature": "(json_path: str) -> set[typing.Any]:", "funcdef": "def"}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"fullname": "outrank.core_utils.summarize_feature_bounds_for_transformers", "modulename": "outrank.core_utils", "qualname": "summarize_feature_bounds_for_transformers", "kind": "function", "doc": "
    summarization auxilliary method for generating JSON-based specs
    \n", "signature": "(\tbounds_object_storage: Any,\tfeature_types: list[str],\ttask_name: str,\tlabel_name: str,\tgranularity: int = 15,\toutput_summary_table_only: bool = False):", "funcdef": "def"}, "outrank.core_utils.summarize_rare_counts": {"fullname": "outrank.core_utils.summarize_rare_counts", "modulename": "outrank.core_utils", "qualname": "summarize_rare_counts", "kind": "function", "doc": "
    Write rare values
    \n", "signature": "(\tterm_counter: Any,\targs: Any,\tcardinality_object: Any,\tobject_info: outrank.core_utils.DatasetInformationStorage) -> None:", "funcdef": "def"}, "outrank.feature_transformations": {"fullname": "outrank.feature_transformations", "modulename": "outrank.feature_transformations", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault": {"fullname": "outrank.feature_transformations.feature_transformer_vault", "modulename": "outrank.feature_transformations.feature_transformer_vault", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "qualname": "MINIMAL_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)'}"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "qualname": "DEFAULT_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)', '_tr_div(x,abs(x))*log(abs(x))': 'np.divide(X, np.abs(X)) * np.log(np.abs(X))', '_tr_log(x + sqrt(pow(x,2), 1)': 'np.log(X + np.sqrt(np.power(X, 2) + 1))', '_tr_log*sqrt': 'np.log(X + 1) * np.sqrt(X)', '_tr_log*100': 'np.round(np.log(X + 1) * 100, 0)', '_tr_nonzero': 'np.where(X != 0, 1, 0)', '_tr_round(div(x,max))': 'np.round(np.divide(X, np.max(X)), 0)'}"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "FW_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)', '_tr_div(x,abs(x))*log(abs(x))': 'np.divide(X, np.abs(X)) * np.log(np.abs(X))', '_tr_log(x + sqrt(pow(x,2), 1)': 'np.log(X + np.sqrt(np.power(X, 2) + 1))', '_tr_log*sqrt': 'np.log(X + 1) * np.sqrt(X)', '_tr_log*100': 'np.round(np.log(X + 1) * 100, 0)', '_tr_nonzero': 'np.where(X != 0, 1, 0)', '_tr_round(div(x,max))': 'np.round(np.divide(X, np.max(X)), 0)', '_tr_fw_sqrt_res_1_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*1,0), 0))', '_tr_fw_log_res_1_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*1,0), 0))', '_tr_fw_log_res_1_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*1,0), 0))', '_tr_fw_log_res_1_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*1,0), 0))', '_tr_fw_log_res_1_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*1,0), 0))', '_tr_fw_log_res_1_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*1,0), 0))', '_tr_fw_log_res_1_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*1,0), 0))', '_tr_fw_log_res_1_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*1,0), 0))', '_tr_fw_log_res_1_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*1,0), 0))', '_tr_fw_sqrt_res_10_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*10,0), 0))', '_tr_fw_log_res_10_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*10,0), 0))', '_tr_fw_log_res_10_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*10,0), 0))', '_tr_fw_log_res_10_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*10,0), 0))', '_tr_fw_log_res_10_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*10,0), 0))', '_tr_fw_log_res_10_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*10,0), 0))', '_tr_fw_log_res_10_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*10,0), 0))', '_tr_fw_log_res_10_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*10,0), 0))', '_tr_fw_log_res_10_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*10,0), 0))', '_tr_fw_sqrt_res_50_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*50,0), 0))', '_tr_fw_log_res_50_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*50,0), 0))', '_tr_fw_log_res_50_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*50,0), 0))', '_tr_fw_log_res_50_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*50,0), 0))', '_tr_fw_log_res_50_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*50,0), 0))', '_tr_fw_log_res_50_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*50,0), 0))', '_tr_fw_log_res_50_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*50,0), 0))', '_tr_fw_log_res_50_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*50,0), 0))', '_tr_fw_log_res_50_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*50,0), 0))', '_tr_fw_sqrt_res_100_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*100,0), 0))', '_tr_fw_log_res_100_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*100,0), 0))', '_tr_fw_log_res_100_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*100,0), 0))', '_tr_fw_log_res_100_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*100,0), 0))', '_tr_fw_log_res_100_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*100,0), 0))', '_tr_fw_log_res_100_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*100,0), 0))', '_tr_fw_log_res_100_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*100,0), 0))', '_tr_fw_log_res_100_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*100,0), 0))', '_tr_fw_log_res_100_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*100,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*1,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*10,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*50,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*100,0), 0))'}"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "resolution_range", "kind": "variable", "doc": "
    \n", "default_value": "[1, 10, 50, 100]"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "greater_than_range", "kind": "variable", "doc": "
    \n", "default_value": "[1, 2, 4, 8, 16, 32, 64, 96]"}, "outrank.feature_transformations.ranking_transformers": {"fullname": "outrank.feature_transformations.ranking_transformers", "modulename": "outrank.feature_transformations.ranking_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise", "kind": "class", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise.noise_preset", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise.construct_new_features", "kind": "function", "doc": "
    Generate a few standard noise distributions
    \n", "signature": "(self, dataframe: pandas.core.frame.DataFrame, label_column=None):", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric", "kind": "class", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.__init__", "kind": "function", "doc": "
    \n", "signature": "(numeric_column_names: set[str], preset: str = 'default')"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.numeric_column_names", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.constructed_feature_names", "kind": "variable", "doc": "
    \n", "annotation": ": set[str]"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.max_maj_support", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.nan_prop_support", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.get_vals", "kind": "function", "doc": "
    \n", "signature": "(self, tmp_df: pandas.core.frame.DataFrame, col_name: str) -> Any:", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.construct_baseline_features", "kind": "function", "doc": "
    \n", "signature": "(self, dataframe: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.construct_new_features", "kind": "function", "doc": "
    \n", "signature": "(self, dataframe: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.task_generators": {"fullname": "outrank.task_generators", "modulename": "outrank.task_generators", "kind": "module", "doc": "
    \n"}, "outrank.task_generators.logger": {"fullname": "outrank.task_generators.logger", "modulename": "outrank.task_generators", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.task_generators.outrank_task_generate_data_set": {"fullname": "outrank.task_generators.outrank_task_generate_data_set", "modulename": "outrank.task_generators", "qualname": "outrank_task_generate_data_set", "kind": "function", "doc": "
    Core method for generating data sets
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.task_ranking": {"fullname": "outrank.task_ranking", "modulename": "outrank.task_ranking", "kind": "module", "doc": "
    \n"}, "outrank.task_ranking.outrank_task_conduct_ranking": {"fullname": "outrank.task_ranking.outrank_task_conduct_ranking", "modulename": "outrank.task_ranking", "qualname": "outrank_task_conduct_ranking", "kind": "function", "doc": "
    \n", "signature": "(args: Any):", "funcdef": "def"}, "outrank.task_selftest": {"fullname": "outrank.task_selftest", "modulename": "outrank.task_selftest", "kind": "module", "doc": "
    \n"}, "outrank.task_selftest.logger": {"fullname": "outrank.task_selftest.logger", "modulename": "outrank.task_selftest", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.task_selftest.conduct_self_test": {"fullname": "outrank.task_selftest.conduct_self_test", "modulename": "outrank.task_selftest", "qualname": "conduct_self_test", "kind": "function", "doc": "
    \n", "signature": "():", "funcdef": "def"}, "outrank.task_summary": {"fullname": "outrank.task_summary", "modulename": "outrank.task_summary", "kind": "module", "doc": "
    \n"}, "outrank.task_summary.outrank_task_result_summary": {"fullname": "outrank.task_summary.outrank_task_result_summary", "modulename": "outrank.task_summary", "qualname": "outrank_task_result_summary", "kind": "function", "doc": "
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.task_visualization": {"fullname": "outrank.task_visualization", "modulename": "outrank.task_visualization", "kind": "module", "doc": "
    \n"}, "outrank.task_visualization.outrank_task_visualize_results": {"fullname": "outrank.task_visualization.outrank_task_visualize_results", "modulename": "outrank.task_visualization", "qualname": "outrank_task_visualize_results", "kind": "function", "doc": "
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.visualizations": {"fullname": "outrank.visualizations", "modulename": "outrank.visualizations", "kind": "module", "doc": "
    \n"}, "outrank.visualizations.ranking_visualization": {"fullname": "outrank.visualizations.ranking_visualization", "modulename": "outrank.visualizations.ranking_visualization", "kind": "module", "doc": "
    \n"}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"fullname": "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_hierarchical_clusters", "kind": "function", "doc": "
    A method for visualization of hierarchical clusters w.r.t. different linkage functions
    \n", "signature": "(\ttriplet_dataframe: pandas.core.frame.DataFrame,\toutput_folder: str,\timage_format: str = 'png',\tmax_num_clusters: int = 100) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"fullname": "outrank.visualizations.ranking_visualization.visualize_heatmap", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_heatmap", "kind": "function", "doc": "
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\timage_format: str) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"fullname": "outrank.visualizations.ranking_visualization.visualize_barplots", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_barplots", "kind": "function", "doc": "
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\treference_json: str,\timage_format: str,\tlabel: str,\theuristic: str) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_all": {"fullname": "outrank.visualizations.ranking_visualization.visualize_all", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_all", "kind": "function", "doc": "
    A method for visualization of the obtained feature interaction maps.
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\tlabel: str = '',\treference_json: str = '',\timage_format: str = 'png',\theuristic: str = 'MI') -> None:", "funcdef": "def"}}, "docInfo": {"outrank": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 234}, "outrank.algorithms": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"qualname": 2, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 9}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"qualname": 2, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 6}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "outrank.algorithms.importance_estimator": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_MI": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.numba_mi": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 23, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 18, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 21}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 204, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "outrank.algorithms.sketches": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 3}, "outrank.core_ranking": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"qualname": 4, "fullname": 7, "annotation": 4, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.IGNORED_VALUES": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.encode_int_column": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 12}, "outrank.core_ranking.mixed_rank_graph": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 81, "bases": 0, "doc": 19}, "outrank.core_ranking.enrich_with_transformations": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 92, "bases": 0, "doc": 13}, "outrank.core_ranking.compute_combined_features": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 103, "bases": 0, "doc": 11}, "outrank.core_ranking.compute_expanded_multivalue_features": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 41}, "outrank.core_ranking.compute_subfeatures": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 70}, "outrank.core_ranking.include_noisy_features": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 11}, "outrank.core_ranking.compute_coverage": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 7}, "outrank.core_ranking.compute_feature_memory_consumption": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 10}, "outrank.core_ranking.compute_value_counts": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 6}, "outrank.core_ranking.compute_cardinalities": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 7}, "outrank.core_ranking.compute_bounds_increment": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 72, "bases": 0, "doc": 3}, "outrank.core_ranking.compute_batch_ranking": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 197, "bases": 0, "doc": 11}, "outrank.core_ranking.get_num_of_instances": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 15}, "outrank.core_ranking.get_grouped_df": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 12}, "outrank.core_ranking.checkpoint_importances_df": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 12}, "outrank.core_ranking.estimate_importances_minibatches": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 376, "bases": 0, "doc": 48}, "outrank.core_selftest": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.pro_tips": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 303, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.write_json_dump_to_file": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 30, "bases": 0, "doc": 3}, "outrank.core_utils.internal_hash": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 17}, "outrank.core_utils.DatasetInformationStorage": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "outrank.core_utils.DatasetInformationStorage.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 111, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.data_path": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.column_names": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.column_types": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.encoding": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.NumericFeatureSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.minimum": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.maximum": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.median": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.NominalFeatureSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.BatchRankingSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary.step_times": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.display_random_tip": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "outrank.core_utils.get_dataset_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.core_utils.display_tool_name": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "outrank.core_utils.parse_ob_line": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 7}, "outrank.core_utils.parse_ob_line_vw": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 15}, "outrank.core_utils.parse_ob_csv_line": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 10}, "outrank.core_utils.generic_line_parser": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 13}, "outrank.core_utils.read_reference_json": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 9}, "outrank.core_utils.parse_namespace": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 9}, "outrank.core_utils.read_column_names": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 6}, "outrank.core_utils.parse_ob_vw_feature_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_ob_raw_feature_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_ob_feature_information": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_csv_with_description_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.parse_csv_raw": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.extract_features_from_reference_JSON": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 10}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 10}, "outrank.core_utils.summarize_rare_counts": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 5}, "outrank.feature_transformations": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"qualname": 0, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 56, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 173, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"qualname": 0, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 4589, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 4, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 47, "bases": 0, "doc": 8}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"qualname": 4, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "outrank.task_generators": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_generators.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_generators.outrank_task_generate_data_set": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 8}, "outrank.task_ranking": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_ranking.outrank_task_conduct_ranking": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.task_selftest": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_selftest.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_selftest.conduct_self_test": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "outrank.task_summary": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_summary.outrank_task_result_summary": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "outrank.task_visualization": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_visualization.outrank_task_visualize_results": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "outrank.visualizations": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 15}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 93, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_all": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 135, "bases": 0, "doc": 13}}, "length": 139, "save": true}, "index": {"qualname": {"root": {"3": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 2}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 11}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 5}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 1}, "x": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 4}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "j": {"docs": {"outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 9, "r": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 2}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}, "w": {"docs": {"outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 8}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 9}}}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 4}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}, "b": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 6}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 4}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 2}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}}, "fullname": {"root": {"3": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms": {"tf": 1}, "outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_selftest": {"tf": 1}, "outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}, "outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}, "outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.4142135623730951}, "outrank.visualizations": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 139}}}}}}, "f": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}, "b": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 6}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms": {"tf": 1}, "outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 29}}}}}}}}, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "j": {"docs": {"outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 35, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 8}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 49}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 2}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}, "w": {"docs": {"outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}}, "df": 1, "i": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 8, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 1}, "x": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}}, "df": 6}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 2}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 10}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 45}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 11}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 10}}}, "s": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_selftest": {"tf": 1}, "outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 69}}, "l": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 5}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 9}}, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 4}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 11}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_selftest": {"tf": 1}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 3}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 6}}}, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 9, "r": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 9}}}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 5, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 8}}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 7, "s": {"docs": {"outrank.visualizations": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 6}}}}}}, "e": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 23}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 21}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}, "outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}, "outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.4142135623730951}}, "df": 12}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}}, "annotation": {"root": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 18, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1.4142135623730951}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 7}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 2}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 2}}}}}, "default_value": {"root": {"0": {"1": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "2": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 2}, "4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "8": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 22.715633383201094}}, "df": 3}, "1": {"0": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8.06225774829855}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 3}, "docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 2}, "6": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {"outrank.core_utils.pro_tips": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 10.198039027185569}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 6}, "2": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.830951894845301}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 3}, "3": {"2": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "5": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "6": {"4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "8": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "9": {"6": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"outrank.core_ranking.logger": {"tf": 1.4142135623730951}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.795831523312719}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 12.288205727444508}, "outrank.task_generators.logger": {"tf": 1.4142135623730951}, "outrank.task_selftest.logger": {"tf": 1.4142135623730951}}, "df": 10, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 5}, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 3.1622776601683795}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.74734012447073}}, "df": 3, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1.4142135623730951}, "outrank.task_generators.logger": {"tf": 1.4142135623730951}, "outrank.task_selftest.logger": {"tf": 1.4142135623730951}}, "df": 3}}}, "*": {"1": {"0": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.6457513110645907}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.61895003862225}}, "df": 3}}}}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 16}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 5}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "v": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "x": {"2": {"7": {"docs": {"outrank.core_utils.pro_tips": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 4}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 6.324555320336759}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.49468024894146}}, "df": 4}, "docs": {}, "df": 0}, "docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.449489742783178}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.795831523312719}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.130067012440755}}, "df": 3, "+": {"1": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}}}}}}, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 3.872983346207417}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "w": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}}, "df": 2}}, "b": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 2.8284271247461903}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "x": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.449489742783178}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.58257569495584}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.08679276123039}}, "df": 3}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "s": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.445523142259598}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 3.1622776601683795}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.74734012447073}}, "df": 3, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 16.0312195418814}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "signature": {"root": {"0": {"0": {"5": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}, "1": {"0": {"0": {"0": {"0": {"0": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "5": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}, "docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}}, "df": 2}, "2": {"0": {"0": {"0": {"0": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "3": {"9": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2}, "outrank.core_utils.parse_ob_line": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 2.8284271247461903}}, "df": 7}, "docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}, "8": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 3.1622776601683795}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 4.69041575982343}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 5.477225575051661}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 5.477225575051661}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 4.898979485566356}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 5.656854249492381}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 4.242640687119285}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 3.7416573867739413}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 4.242640687119285}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 12.806248474865697}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 5.830951894845301}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 3.4641016151377544}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 3.7416573867739413}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 4.69041575982343}, "outrank.core_ranking.encode_int_column": {"tf": 6.855654600401044}, "outrank.core_ranking.mixed_rank_graph": {"tf": 8}, "outrank.core_ranking.enrich_with_transformations": {"tf": 8.54400374531753}, "outrank.core_ranking.compute_combined_features": {"tf": 9.1104335791443}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 8.246211251235321}, "outrank.core_ranking.compute_subfeatures": {"tf": 8.246211251235321}, "outrank.core_ranking.include_noisy_features": {"tf": 7.681145747868608}, "outrank.core_ranking.compute_coverage": {"tf": 7.14142842854285}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 7.14142842854285}, "outrank.core_ranking.compute_value_counts": {"tf": 5.830951894845301}, "outrank.core_ranking.compute_cardinalities": {"tf": 6}, "outrank.core_ranking.compute_bounds_increment": {"tf": 7.54983443527075}, "outrank.core_ranking.compute_batch_ranking": {"tf": 12.449899597988733}, "outrank.core_ranking.get_num_of_instances": {"tf": 4}, "outrank.core_ranking.get_grouped_df": {"tf": 6.855654600401044}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 5.830951894845301}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 17.204650534085253}, "outrank.core_utils.write_json_dump_to_file": {"tf": 4.898979485566356}, "outrank.core_utils.internal_hash": {"tf": 4}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 9.38083151964686}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 7}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 4.47213595499958}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 7.3484692283495345}, "outrank.core_utils.display_random_tip": {"tf": 3}, "outrank.core_utils.get_dataset_info": {"tf": 3.7416573867739413}, "outrank.core_utils.display_tool_name": {"tf": 3}, "outrank.core_utils.parse_ob_line": {"tf": 7.416198487095663}, "outrank.core_utils.parse_ob_line_vw": {"tf": 8.831760866327848}, "outrank.core_utils.parse_ob_csv_line": {"tf": 7.14142842854285}, "outrank.core_utils.generic_line_parser": {"tf": 8.94427190999916}, "outrank.core_utils.read_reference_json": {"tf": 4.69041575982343}, "outrank.core_utils.parse_namespace": {"tf": 6.082762530298219}, "outrank.core_utils.read_column_names": {"tf": 4.58257569495584}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_ob_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_csv_raw": {"tf": 4.47213595499958}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 5}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 8.774964387392123}, "outrank.core_utils.summarize_rare_counts": {"tf": 7.211102550927978}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 6.164414002968976}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 5.744562646538029}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 6.324555320336759}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 5.656854249492381}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 5.656854249492381}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 3.1622776601683795}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 3.7416573867739413}, "outrank.task_selftest.conduct_self_test": {"tf": 2.6457513110645907}, "outrank.task_summary.outrank_task_result_summary": {"tf": 3.1622776601683795}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 3.1622776601683795}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 8.366600265340756}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 6.855654600401044}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 8.602325267042627}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 10.295630140987}}, "df": 69, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1.4142135623730951}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.7320508075688772}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 2.449489742783178}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 3}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 2}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}}, "df": 32}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 24}}}}, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 29}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 3}}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1.4142135623730951}}, "df": 4}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 5}}, "t": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 10}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_batch_ranking": {"tf": 2.6457513110645907}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 3.4641016151377544}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 2.6457513110645907}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.7320508075688772}, "outrank.core_utils.generic_line_parser": {"tf": 1.4142135623730951}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 2}, "outrank.core_utils.read_column_names": {"tf": 1.4142135623730951}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 2.23606797749979}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 2.23606797749979}}, "df": 33, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}}, "df": 14}}}, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 7}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 9}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 6}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}, "x": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "f": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}}, "df": 1, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 4}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.7320508075688772}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 7}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 4, "s": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "l": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 4}}}}}, "x": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 4}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.encode_int_column": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 8}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.core_ranking.encode_int_column": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.449489742783178}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 8}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 6}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 4}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.449489742783178}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 10}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 7, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_value_counts": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_cardinalities": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 6}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 3}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 4}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.4142135623730951}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 2}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1.7320508075688772}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 17}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 5, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 2}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.23606797749979}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 13}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 5}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 7}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 8}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 8}}}, "f": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}}, "df": 2}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0}}, "doc": {"root": {"0": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}, "1": {"2": {"5": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "5": {"1": {"2": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"outrank": {"tf": 9.219544457292887}, "outrank.algorithms": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1.7320508075688772}, "outrank.core_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.logger": {"tf": 1.7320508075688772}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1.7320508075688772}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1.7320508075688772}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1.7320508075688772}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1.7320508075688772}, "outrank.core_ranking.encode_int_column": {"tf": 1.7320508075688772}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 2.23606797749979}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_value_counts": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_cardinalities": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_selftest": {"tf": 1.7320508075688772}, "outrank.core_utils": {"tf": 1.7320508075688772}, "outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1.7320508075688772}, "outrank.core_utils.internal_hash": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1.7320508075688772}, "outrank.core_utils.display_random_tip": {"tf": 1.7320508075688772}, "outrank.core_utils.get_dataset_info": {"tf": 1.7320508075688772}, "outrank.core_utils.display_tool_name": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.4142135623730951}, "outrank.core_utils.generic_line_parser": {"tf": 1.7320508075688772}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1.4142135623730951}, "outrank.core_utils.read_column_names": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_csv_raw": {"tf": 1.7320508075688772}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1.4142135623730951}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.4142135623730951}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.4142135623730951}, "outrank.feature_transformations": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1.7320508075688772}, "outrank.task_generators": {"tf": 1.7320508075688772}, "outrank.task_generators.logger": {"tf": 1.7320508075688772}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1.7320508075688772}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.7320508075688772}, "outrank.task_selftest": {"tf": 1.7320508075688772}, "outrank.task_selftest.logger": {"tf": 1.7320508075688772}, "outrank.task_selftest.conduct_self_test": {"tf": 1.7320508075688772}, "outrank.task_summary": {"tf": 1.7320508075688772}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.7320508075688772}, "outrank.task_visualization": {"tf": 1.7320508075688772}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.7320508075688772}, "outrank.visualizations": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1.7320508075688772}}, "df": 139, "w": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 4}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "o": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 5, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 2.449489742783178}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 11}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 2.6457513110645907}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 4, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 15}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1, "d": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 1, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 9, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.4142135623730951}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 27, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 4}, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 2, "d": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 3}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}, "|": {"docs": {}, "df": 0, "*": {"docs": {}, "df": 0, "|": {"docs": {}, "df": 0, "b": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 13, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 2}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 10, "a": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}, "b": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "c": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 8}}}}}}, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 2}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 3}, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 4}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 8, "d": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 2}}}}, "y": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}}, "df": 2}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 3, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 9}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}}, "df": 1, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4, "s": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"outrank": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 3}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"outrank": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 5}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}}}}}}}}}, "f": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 3, "r": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 3}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 3, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"outrank": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1, "n": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 11}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {"outrank": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 8}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}, "w": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"outrank.core_ranking.encode_int_column": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 2}}}}}}}}}, "x": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 4}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
+    /** pdoc search index */const docs = {"version": "0.9.5", "fields": ["qualname", "fullname", "annotation", "default_value", "signature", "bases", "doc"], "ref": "fullname", "documentStore": {"docs": {"outrank": {"fullname": "outrank", "modulename": "outrank", "kind": "module", "doc": "
    Welcome to OutRank's documentation!
    \n\n
    All functions/methods can be searched-for (search bar on the left).
    \n\n
    This tool enables fast screening of feature-feature interactions. Its purpose is to give the user fast insight into potential redundancies/anomalies in the data.\nIt is implemented to operate in _mini batches_, it traverses the raw data incrementally, refining the rankings as it goes along. The core operation, interaction ranking, outputs triplets which look as follows:
    \n\n
    featureA    featureB    0.512\nfeatureA    featureC    0.125\n
    \n\n
    Setup
    \n\n
    \n
    pip install outrank\n
    \n
    \n\n
    and test a minimal cycle with
    \n\n
    \n
    outrank --task selftest\n
    \n
    \n\n
    if this passes, you can be pretty certain OutRank will perform as intended. OutRank's primary use case is as a CLI tool, begin exploring with
    \n\n
    \n
    outrank --help\n
    \n
    \n\n
    Example use cases
    \n\n
      \n
    • A minimal showcase of performing feature ranking on a generic CSV is demonstrated with this example.
      • \n
    • More examples demonstrating OutRank's capabilities are also available.
      • \n
    \n"}, "outrank.algorithms": {"fullname": "outrank.algorithms", "modulename": "outrank.algorithms", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking": {"fullname": "outrank.algorithms.feature_ranking", "modulename": "outrank.algorithms.feature_ranking", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "numba_unique", "kind": "function", "doc": "
    Identify unique elements in an array, fast
    \n", "signature": "(a):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "compute_conditional_entropy", "kind": "function", "doc": "
    \n", "signature": "(\tY_classes,\tclass_values,\tclass_var_shape,\tinitial_prob,\tnonzero_counts):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "compute_entropies", "kind": "function", "doc": "
    Core entropy computation function
    \n", "signature": "(X, Y, all_events, f_values, f_value_counts, cardinality_correction):", "funcdef": "def"}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"fullname": "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba", "modulename": "outrank.algorithms.feature_ranking.ranking_mi_numba", "qualname": "mutual_info_estimator_numba", "kind": "function", "doc": "
    Core estimator logic. Compute unique elements, subset if required
    \n", "signature": "(Y, X, approximation_factor=1, cardinality_correction=False):", "funcdef": "def"}, "outrank.algorithms.importance_estimator": {"fullname": "outrank.algorithms.importance_estimator", "modulename": "outrank.algorithms.importance_estimator", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.importance_estimator.sklearn_MI": {"fullname": "outrank.algorithms.importance_estimator.sklearn_MI", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_MI", "kind": "function", "doc": "
    \n", "signature": "(vector_first: Any, vector_second: Any) -> float:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"fullname": "outrank.algorithms.importance_estimator.sklearn_surrogate", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_surrogate", "kind": "function", "doc": "
    \n", "signature": "(vector_first: Any, vector_second: Any, surrogate_model: str) -> float:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.numba_mi": {"fullname": "outrank.algorithms.importance_estimator.numba_mi", "modulename": "outrank.algorithms.importance_estimator", "qualname": "numba_mi", "kind": "function", "doc": "
    \n", "signature": "(vector_first, vector_second, heuristic):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"fullname": "outrank.algorithms.importance_estimator.sklearn_mi_adj", "modulename": "outrank.algorithms.importance_estimator", "qualname": "sklearn_mi_adj", "kind": "function", "doc": "
    \n", "signature": "(vector_first, vector_second):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"fullname": "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise", "modulename": "outrank.algorithms.importance_estimator", "qualname": "get_importances_estimate_pairwise", "kind": "function", "doc": "
    A method for parallel importances estimation. As interaction scoring is independent, individual scores can be computed in parallel.
    \n", "signature": "(combination, args, tmp_df):", "funcdef": "def"}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"fullname": "outrank.algorithms.importance_estimator.rank_features_3MR", "modulename": "outrank.algorithms.importance_estimator", "qualname": "rank_features_3MR", "kind": "function", "doc": "
    \n", "signature": "(\trelevance_dict: dict[str, float],\tredundancy_dict: dict[tuple[typing.Any, typing.Any], typing.Any],\trelational_dict: dict[tuple[typing.Any, typing.Any], typing.Any],\tstrategy: str = 'median',\talpha: float = 1,\tbeta: float = 1) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"fullname": "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic", "modulename": "outrank.algorithms.importance_estimator", "qualname": "get_importances_estimate_nonmyopic", "kind": "function", "doc": "
    \n", "signature": "(args: Any, tmp_df: pandas.core.frame.DataFrame):", "funcdef": "def"}, "outrank.algorithms.sketches": {"fullname": "outrank.algorithms.sketches", "modulename": "outrank.algorithms.sketches", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "kind": "module", "doc": "
    This module implements probabilistic data structure which is able to calculate the cardinality of large multisets in a single pass using little auxiliary memory
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache", "kind": "class", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.__init__", "kind": "function", "doc": "
    \n", "signature": "(error_rate=0.005)"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.p", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.m", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.warmup_set", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.warmup_size", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.width", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.hll_flag", "kind": "variable", "doc": "
    \n"}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"fullname": "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add", "modulename": "outrank.algorithms.sketches.counting_ultiloglog", "qualname": "HyperLogLogWCache.add", "kind": "function", "doc": "
    \n", "signature": "(self, value):", "funcdef": "def"}, "outrank.algorithms.synthetic_data_generators": {"fullname": "outrank.algorithms.synthetic_data_generators", "modulename": "outrank.algorithms.synthetic_data_generators", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"fullname": "outrank.algorithms.synthetic_data_generators.generator_naive", "modulename": "outrank.algorithms.synthetic_data_generators.generator_naive", "kind": "module", "doc": "
    \n"}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"fullname": "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix", "modulename": "outrank.algorithms.synthetic_data_generators.generator_naive", "qualname": "generate_random_matrix", "kind": "function", "doc": "
    \n", "signature": "(num_features=100, size=20000):", "funcdef": "def"}, "outrank.core_ranking": {"fullname": "outrank.core_ranking", "modulename": "outrank.core_ranking", "kind": "module", "doc": "
    \n"}, "outrank.core_ranking.logger": {"fullname": "outrank.core_ranking.logger", "modulename": "outrank.core_ranking", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"fullname": "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE", "modulename": "outrank.core_ranking", "qualname": "GLOBAL_CARDINALITY_STORAGE", "kind": "variable", "doc": "
    \n", "annotation": ": dict[typing.Any, typing.Any]", "default_value": "{}"}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"fullname": "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE", "modulename": "outrank.core_ranking", "qualname": "GLOBAL_RARE_VALUE_STORAGE", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, typing.Any]", "default_value": "Counter()"}, "outrank.core_ranking.IGNORED_VALUES": {"fullname": "outrank.core_ranking.IGNORED_VALUES", "modulename": "outrank.core_ranking", "qualname": "IGNORED_VALUES", "kind": "variable", "doc": "
    \n", "default_value": "set()"}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"fullname": "outrank.core_ranking.HYPERLL_ERROR_BOUND", "modulename": "outrank.core_ranking", "qualname": "HYPERLL_ERROR_BOUND", "kind": "variable", "doc": "
    \n", "default_value": "0.02"}, "outrank.core_ranking.mixed_rank_graph": {"fullname": "outrank.core_ranking.mixed_rank_graph", "modulename": "outrank.core_ranking", "qualname": "mixed_rank_graph", "kind": "function", "doc": "
    Compute the full mixed rank graph corresponding to all pairwise feature interactions based on the selected heuristic
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any,\tcpu_pool: Any,\tpbar: Any) -> outrank.core_utils.BatchRankingSummary:", "funcdef": "def"}, "outrank.core_ranking.enrich_with_transformations": {"fullname": "outrank.core_ranking.enrich_with_transformations", "modulename": "outrank.core_ranking", "qualname": "enrich_with_transformations", "kind": "function", "doc": "
    Construct a collection of new features based on pre-defined transformations/rules
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tnum_col_types: set[str],\tlogger: Any,\targs: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_combined_features": {"fullname": "outrank.core_ranking.compute_combined_features", "modulename": "outrank.core_ranking", "qualname": "compute_combined_features", "kind": "function", "doc": "
    Compute higher order features via xxhash-based trick.
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any,\tis_3mr: bool = False) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_expanded_multivalue_features": {"fullname": "outrank.core_ranking.compute_expanded_multivalue_features", "modulename": "outrank.core_ranking", "qualname": "compute_expanded_multivalue_features", "kind": "function", "doc": "
    Compute one-hot encoded feature space based on each designated multivalue feature. E.g., feature with value \"a,b,c\" becomes three features, values of which are presence of a given value in a mutlivalue feature of choice.
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_subfeatures": {"fullname": "outrank.core_ranking.compute_subfeatures", "modulename": "outrank.core_ranking", "qualname": "compute_subfeatures", "kind": "function", "doc": "
    Compute derived features that are more fine-grained. Implements logic around two operators that govern feature construction.\n->: One sided construction - every value from left side is fine, separate ones from the right side feature will be considered.\n<->: Two sided construction - two-sided values present. This means that each value from a is combined with each from b, forming |A|*|B| new features (one-hot encoded)
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any,\tpbar: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.include_noisy_features": {"fullname": "outrank.core_ranking.include_noisy_features", "modulename": "outrank.core_ranking", "qualname": "include_noisy_features", "kind": "function", "doc": "
    Add randomized features that serve as a sanity check
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tlogger: Any,\targs: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.compute_coverage": {"fullname": "outrank.core_ranking.compute_coverage", "modulename": "outrank.core_ranking", "qualname": "compute_coverage", "kind": "function", "doc": "
    Compute coverage of features, incrementally
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any) -> dict[str, set[str]]:", "funcdef": "def"}, "outrank.core_ranking.compute_feature_memory_consumption": {"fullname": "outrank.core_ranking.compute_feature_memory_consumption", "modulename": "outrank.core_ranking", "qualname": "compute_feature_memory_consumption", "kind": "function", "doc": "
    An approximation of how much feature take up
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\targs: Any) -> dict[str, set[str]]:", "funcdef": "def"}, "outrank.core_ranking.compute_value_counts": {"fullname": "outrank.core_ranking.compute_value_counts", "modulename": "outrank.core_ranking", "qualname": "compute_value_counts", "kind": "function", "doc": "
    Update the count structure
    \n", "signature": "(input_dataframe: pandas.core.frame.DataFrame, args: Any):", "funcdef": "def"}, "outrank.core_ranking.compute_cardinalities": {"fullname": "outrank.core_ranking.compute_cardinalities", "modulename": "outrank.core_ranking", "qualname": "compute_cardinalities", "kind": "function", "doc": "
    Compute cardinalities of features, incrementally
    \n", "signature": "(input_dataframe: pandas.core.frame.DataFrame, pbar: Any) -> None:", "funcdef": "def"}, "outrank.core_ranking.compute_bounds_increment": {"fullname": "outrank.core_ranking.compute_bounds_increment", "modulename": "outrank.core_ranking", "qualname": "compute_bounds_increment", "kind": "function", "doc": "
    \n", "signature": "(\tinput_dataframe: pandas.core.frame.DataFrame,\tnumeric_column_types: set[str]) -> dict[str, typing.Any]:", "funcdef": "def"}, "outrank.core_ranking.compute_batch_ranking": {"fullname": "outrank.core_ranking.compute_batch_ranking", "modulename": "outrank.core_ranking", "qualname": "compute_batch_ranking", "kind": "function", "doc": "
    Enrich the feature space and compute the batch importances
    \n", "signature": "(\tline_tmp_storage: list[list[typing.Any]],\tnumeric_column_types: set[str],\targs: Any,\tcpu_pool: Any,\tcolumn_descriptions: list[str],\tlogger: Any,\tpbar: Any) -> tuple[outrank.core_utils.BatchRankingSummary, dict[str, typing.Any], dict[str, set[str]], dict[str, set[str]]]:", "funcdef": "def"}, "outrank.core_ranking.get_num_of_instances": {"fullname": "outrank.core_ranking.get_num_of_instances", "modulename": "outrank.core_ranking", "qualname": "get_num_of_instances", "kind": "function", "doc": "
    Count the number of lines in a file, fast - useful for progress logging
    \n", "signature": "(fname: str) -> int:", "funcdef": "def"}, "outrank.core_ranking.get_grouped_df": {"fullname": "outrank.core_ranking.get_grouped_df", "modulename": "outrank.core_ranking", "qualname": "get_grouped_df", "kind": "function", "doc": "
    A helper method that enables median-based aggregation after processing
    \n", "signature": "(\timportances_df_list: list[tuple[str, str, float]]) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.core_ranking.checkpoint_importances_df": {"fullname": "outrank.core_ranking.checkpoint_importances_df", "modulename": "outrank.core_ranking", "qualname": "checkpoint_importances_df", "kind": "function", "doc": "
    A helper which stores intermediary state - useful for longer runs
    \n", "signature": "(importances_batch: list[tuple[str, str, float]]) -> None:", "funcdef": "def"}, "outrank.core_ranking.estimate_importances_minibatches": {"fullname": "outrank.core_ranking.estimate_importances_minibatches", "modulename": "outrank.core_ranking", "qualname": "estimate_importances_minibatches", "kind": "function", "doc": "
    Interaction score estimator - suitable for example for csv-like input data types.\nThis type of data is normally a single large csv, meaning that minibatch processing needs to\nhappen during incremental handling of the file (that\"s not the case for pre-separated ob data)
    \n", "signature": "(\tinput_file: str,\tcolumn_descriptions: list,\tfw_col_mapping: dict[str, str],\tnumeric_column_types: set,\tbatch_size: int = 100000,\targs: Any = None,\tdata_encoding: str = 'utf-8',\tcpu_pool: Any = None,\tdelimiter: str = '\\t',\tfeature_construction_mode: bool = False,\tlogger: Any = None) -> tuple[list[dict[str, typing.Any]], typing.Any, dict[typing.Any, typing.Any], list[dict[str, typing.Any]], list[dict[str, set[str]]], collections.defaultdict[str, list[set[str]]], dict[str, typing.Any]]:", "funcdef": "def"}, "outrank.core_selftest": {"fullname": "outrank.core_selftest", "modulename": "outrank.core_selftest", "kind": "module", "doc": "
    \n"}, "outrank.core_utils": {"fullname": "outrank.core_utils", "modulename": "outrank.core_utils", "kind": "module", "doc": "
    \n"}, "outrank.core_utils.pro_tips": {"fullname": "outrank.core_utils.pro_tips", "modulename": "outrank.core_utils", "qualname": "pro_tips", "kind": "variable", "doc": "
    \n", "default_value": "['OutRank can construct subfeatures; features based on subspaces. Example command argument is: --subfeature_mapping "feature_a->feature_b;feature_c<->feature_d;feature_c<->feature_e"', 'Heuristic MI-numba-randomized seems like the best of both worlds! (speed + performance).', 'Heuristic surrogate-lr performs cross-validation (internally), keep that in mind!', 'Consider running OutRank on a smaller data sample first, might be enough (--subsampling = a lot).', 'There are two types of combinations supported; unsupervised pairwise ranking (redundancies- --target_ranking_only=False), and supervised combinations - (--interaction_order > 1)', 'Visualization part also includes clustering - this might be very insightful!', 'By default OutRank includes feature cardinality and coverage in feature names (card; cov)', 'Intermediary checkpoints (tmp_checkpoint.tsv) might already give you insights during longer runs.', 'In theory, you can rank redundancies of combined features (--interaction_order AND --target_ranking_only=False).', 'Give it as many threads as physically possible (--num_threads).', 'You can speed up ranking by diminishing feature buffer size (--combination_number_upper_bound determines how many ranking computations per batch will be considered). This, and --subsampling are very powerful together.', 'Want to rank feature transformations, but not sure which ones to choose? --transformers=default should serve as a solid baseline (common DS transformations included).', 'Your target can be any feature! (explaining one feature with others)', 'OutRank uses HyperLogLog for cardinality estimation - this is also a potential usecase (understanding cardinalities across different data sets).', 'Each feature is named as featureName(cardinality, coverage in percents) in the final files.', 'You can generate candidate feature transformation ranges (fw) by using --task=feature_summary_transformers.']"}, "outrank.core_utils.write_json_dump_to_file": {"fullname": "outrank.core_utils.write_json_dump_to_file", "modulename": "outrank.core_utils", "qualname": "write_json_dump_to_file", "kind": "function", "doc": "
    \n", "signature": "(args: Any, config_name: str) -> None:", "funcdef": "def"}, "outrank.core_utils.internal_hash": {"fullname": "outrank.core_utils.internal_hash", "modulename": "outrank.core_utils", "qualname": "internal_hash", "kind": "function", "doc": "
    A generic internal hash used throughout ranking procedure - let's hardcode seed here for sure
    \n", "signature": "(input_obj: str) -> str:", "funcdef": "def"}, "outrank.core_utils.DatasetInformationStorage": {"fullname": "outrank.core_utils.DatasetInformationStorage", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage", "kind": "class", "doc": "
    A generic class for holding properties of a given type of dataset
    \n"}, "outrank.core_utils.DatasetInformationStorage.__init__": {"fullname": "outrank.core_utils.DatasetInformationStorage.__init__", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tdata_path: str,\tcolumn_names: list[str],\tcolumn_types: set[str],\tcol_delimiter: str | None,\tencoding: str,\tfw_map: dict[str, str] | None)"}, "outrank.core_utils.DatasetInformationStorage.data_path": {"fullname": "outrank.core_utils.DatasetInformationStorage.data_path", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.data_path", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.DatasetInformationStorage.column_names": {"fullname": "outrank.core_utils.DatasetInformationStorage.column_names", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.column_names", "kind": "variable", "doc": "
    \n", "annotation": ": list[str]"}, "outrank.core_utils.DatasetInformationStorage.column_types": {"fullname": "outrank.core_utils.DatasetInformationStorage.column_types", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.column_types", "kind": "variable", "doc": "
    \n", "annotation": ": set[str]"}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"fullname": "outrank.core_utils.DatasetInformationStorage.col_delimiter", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.col_delimiter", "kind": "variable", "doc": "
    \n", "annotation": ": str | None"}, "outrank.core_utils.DatasetInformationStorage.encoding": {"fullname": "outrank.core_utils.DatasetInformationStorage.encoding", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.encoding", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"fullname": "outrank.core_utils.DatasetInformationStorage.fw_map", "modulename": "outrank.core_utils", "qualname": "DatasetInformationStorage.fw_map", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, str] | None"}, "outrank.core_utils.NumericFeatureSummary": {"fullname": "outrank.core_utils.NumericFeatureSummary", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary", "kind": "class", "doc": "
    A generic class storing numeric feature statistics
    \n"}, "outrank.core_utils.NumericFeatureSummary.__init__": {"fullname": "outrank.core_utils.NumericFeatureSummary.__init__", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tfeature_name: str,\tminimum: float,\tmaximum: float,\tmedian: float,\tnum_unique: int)"}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"fullname": "outrank.core_utils.NumericFeatureSummary.feature_name", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.feature_name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.NumericFeatureSummary.minimum": {"fullname": "outrank.core_utils.NumericFeatureSummary.minimum", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.minimum", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.maximum": {"fullname": "outrank.core_utils.NumericFeatureSummary.maximum", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.maximum", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.median": {"fullname": "outrank.core_utils.NumericFeatureSummary.median", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.median", "kind": "variable", "doc": "
    \n", "annotation": ": float"}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"fullname": "outrank.core_utils.NumericFeatureSummary.num_unique", "modulename": "outrank.core_utils", "qualname": "NumericFeatureSummary.num_unique", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "outrank.core_utils.NominalFeatureSummary": {"fullname": "outrank.core_utils.NominalFeatureSummary", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary", "kind": "class", "doc": "
    A generic class storing numeric feature statistics
    \n"}, "outrank.core_utils.NominalFeatureSummary.__init__": {"fullname": "outrank.core_utils.NominalFeatureSummary.__init__", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(feature_name: str, num_unique: int)"}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"fullname": "outrank.core_utils.NominalFeatureSummary.feature_name", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.feature_name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"fullname": "outrank.core_utils.NominalFeatureSummary.num_unique", "modulename": "outrank.core_utils", "qualname": "NominalFeatureSummary.num_unique", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "outrank.core_utils.BatchRankingSummary": {"fullname": "outrank.core_utils.BatchRankingSummary", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary", "kind": "class", "doc": "
    A generic class representing batched ranking results
    \n"}, "outrank.core_utils.BatchRankingSummary.__init__": {"fullname": "outrank.core_utils.BatchRankingSummary.__init__", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.__init__", "kind": "function", "doc": "
    \n", "signature": "(\ttriplet_scores: list[tuple[str, str, float]],\tstep_times: dict[str, typing.Any])"}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"fullname": "outrank.core_utils.BatchRankingSummary.triplet_scores", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.triplet_scores", "kind": "variable", "doc": "
    \n", "annotation": ": list[tuple[str, str, float]]"}, "outrank.core_utils.BatchRankingSummary.step_times": {"fullname": "outrank.core_utils.BatchRankingSummary.step_times", "modulename": "outrank.core_utils", "qualname": "BatchRankingSummary.step_times", "kind": "variable", "doc": "
    \n", "annotation": ": dict[str, typing.Any]"}, "outrank.core_utils.display_random_tip": {"fullname": "outrank.core_utils.display_random_tip", "modulename": "outrank.core_utils", "qualname": "display_random_tip", "kind": "function", "doc": "
    \n", "signature": "() -> None:", "funcdef": "def"}, "outrank.core_utils.get_dataset_info": {"fullname": "outrank.core_utils.get_dataset_info", "modulename": "outrank.core_utils", "qualname": "get_dataset_info", "kind": "function", "doc": "
    \n", "signature": "(args: Any):", "funcdef": "def"}, "outrank.core_utils.display_tool_name": {"fullname": "outrank.core_utils.display_tool_name", "modulename": "outrank.core_utils", "qualname": "display_tool_name", "kind": "function", "doc": "
    \n", "signature": "() -> None:", "funcdef": "def"}, "outrank.core_utils.parse_ob_line": {"fullname": "outrank.core_utils.parse_ob_line", "modulename": "outrank.core_utils", "qualname": "parse_ob_line", "kind": "function", "doc": "
    Outbrain line parsing - generic TSVs
    \n", "signature": "(line_string: str, delimiter: str = '\\t', args: Any = None) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_line_vw": {"fullname": "outrank.core_utils.parse_ob_line_vw", "modulename": "outrank.core_utils", "qualname": "parse_ob_line_vw", "kind": "function", "doc": "
    Parse a sparse vw line into a pandas df with pre-defined namespace
    \n", "signature": "(\tline_string: str,\tdelimiter: str,\targs: Any = None,\tfw_col_mapping=None,\ttable_header=None,\tinclude_namespace_info=False) -> list[str | None]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_csv_line": {"fullname": "outrank.core_utils.parse_ob_csv_line", "modulename": "outrank.core_utils", "qualname": "parse_ob_csv_line", "kind": "function", "doc": "
    Data can have commas within JSON field dumps
    \n", "signature": "(line_string: str, delimiter: str = ',', args: Any = None) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.generic_line_parser": {"fullname": "outrank.core_utils.generic_line_parser", "modulename": "outrank.core_utils", "qualname": "generic_line_parser", "kind": "function", "doc": "
    A generic method aimed to parse data from different sources.
    \n", "signature": "(\tline_string: str,\tdelimiter: str,\targs: Any = None,\tfw_col_mapping: Any = None,\ttable_header: Any = None) -> list[typing.Any]:", "funcdef": "def"}, "outrank.core_utils.read_reference_json": {"fullname": "outrank.core_utils.read_reference_json", "modulename": "outrank.core_utils", "qualname": "read_reference_json", "kind": "function", "doc": "
    A helper method for reading a JSON
    \n", "signature": "(json_path) -> dict[str, dict]:", "funcdef": "def"}, "outrank.core_utils.parse_namespace": {"fullname": "outrank.core_utils.parse_namespace", "modulename": "outrank.core_utils", "qualname": "parse_namespace", "kind": "function", "doc": "
    Parse the feature namespace for type awareness
    \n", "signature": "(namespace_path: str) -> tuple[set[str], dict[str, str]]:", "funcdef": "def"}, "outrank.core_utils.read_column_names": {"fullname": "outrank.core_utils.read_column_names", "modulename": "outrank.core_utils", "qualname": "read_column_names", "kind": "function", "doc": "
    Read the col. header
    \n", "signature": "(mapping_file: str) -> list[str]:", "funcdef": "def"}, "outrank.core_utils.parse_ob_vw_feature_information": {"fullname": "outrank.core_utils.parse_ob_vw_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_vw_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_ob_raw_feature_information": {"fullname": "outrank.core_utils.parse_ob_raw_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_raw_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_ob_feature_information": {"fullname": "outrank.core_utils.parse_ob_feature_information", "modulename": "outrank.core_utils", "qualname": "parse_ob_feature_information", "kind": "function", "doc": "
    A generic parser of ob-based data
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_csv_with_description_information": {"fullname": "outrank.core_utils.parse_csv_with_description_information", "modulename": "outrank.core_utils", "qualname": "parse_csv_with_description_information", "kind": "function", "doc": "
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.parse_csv_raw": {"fullname": "outrank.core_utils.parse_csv_raw", "modulename": "outrank.core_utils", "qualname": "parse_csv_raw", "kind": "function", "doc": "
    \n", "signature": "(data_path) -> outrank.core_utils.DatasetInformationStorage:", "funcdef": "def"}, "outrank.core_utils.extract_features_from_reference_JSON": {"fullname": "outrank.core_utils.extract_features_from_reference_JSON", "modulename": "outrank.core_utils", "qualname": "extract_features_from_reference_JSON", "kind": "function", "doc": "
    Given a model's JSON, extract unique features
    \n", "signature": "(json_path: str) -> set[typing.Any]:", "funcdef": "def"}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"fullname": "outrank.core_utils.summarize_feature_bounds_for_transformers", "modulename": "outrank.core_utils", "qualname": "summarize_feature_bounds_for_transformers", "kind": "function", "doc": "
    summarization auxilliary method for generating JSON-based specs
    \n", "signature": "(\tbounds_object_storage: Any,\tfeature_types: list[str],\ttask_name: str,\tlabel_name: str,\tgranularity: int = 15,\toutput_summary_table_only: bool = False):", "funcdef": "def"}, "outrank.core_utils.summarize_rare_counts": {"fullname": "outrank.core_utils.summarize_rare_counts", "modulename": "outrank.core_utils", "qualname": "summarize_rare_counts", "kind": "function", "doc": "
    Write rare values
    \n", "signature": "(\tterm_counter: Any,\targs: Any,\tcardinality_object: Any,\tobject_info: outrank.core_utils.DatasetInformationStorage) -> None:", "funcdef": "def"}, "outrank.feature_transformations": {"fullname": "outrank.feature_transformations", "modulename": "outrank.feature_transformations", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault": {"fullname": "outrank.feature_transformations.feature_transformer_vault", "modulename": "outrank.feature_transformations.feature_transformer_vault", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "qualname": "MINIMAL_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)'}"}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.default_transformers", "qualname": "DEFAULT_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)', '_tr_div(x,abs(x))*log(abs(x))': 'np.divide(X, np.abs(X)) * np.log(np.abs(X))', '_tr_log(x + sqrt(pow(x,2), 1)': 'np.log(X + np.sqrt(np.power(X, 2) + 1))', '_tr_log*sqrt': 'np.log(X + 1) * np.sqrt(X)', '_tr_log*100': 'np.round(np.log(X + 1) * 100, 0)', '_tr_nonzero': 'np.where(X != 0, 1, 0)', '_tr_round(div(x,max))': 'np.round(np.divide(X, np.max(X)), 0)'}"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "FW_TRANSFORMERS", "kind": "variable", "doc": "
    \n", "default_value": "{'_tr_sqrt': 'np.sqrt(X)', '_tr_log(x+1)': 'np.log(X + 1)', '_tr_sqrt(abs(x))': 'np.sqrt(np.abs(X))', '_tr_log(abs(x)+1)': 'np.log(np.abs(X) + 1)', '_tr_div(x,abs(x))*log(abs(x))': 'np.divide(X, np.abs(X)) * np.log(np.abs(X))', '_tr_log(x + sqrt(pow(x,2), 1)': 'np.log(X + np.sqrt(np.power(X, 2) + 1))', '_tr_log*sqrt': 'np.log(X + 1) * np.sqrt(X)', '_tr_log*100': 'np.round(np.log(X + 1) * 100, 0)', '_tr_nonzero': 'np.where(X != 0, 1, 0)', '_tr_round(div(x,max))': 'np.round(np.divide(X, np.max(X)), 0)', '_tr_fw_sqrt_res_1_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*1,0), 0))', '_tr_fw_log_res_1_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*1,0), 0))', '_tr_fw_log_res_1_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*1,0), 0))', '_tr_fw_log_res_1_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*1,0), 0))', '_tr_fw_log_res_1_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*1,0), 0))', '_tr_fw_log_res_1_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*1,0), 0))', '_tr_fw_log_res_1_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*1,0), 0))', '_tr_fw_log_res_1_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*1,0), 0))', '_tr_fw_sqrt_res_1_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*1,0), 0))', '_tr_fw_log_res_1_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*1,0), 0))', '_tr_fw_sqrt_res_10_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*10,0), 0))', '_tr_fw_log_res_10_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*10,0), 0))', '_tr_fw_log_res_10_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*10,0), 0))', '_tr_fw_log_res_10_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*10,0), 0))', '_tr_fw_log_res_10_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*10,0), 0))', '_tr_fw_log_res_10_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*10,0), 0))', '_tr_fw_log_res_10_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*10,0), 0))', '_tr_fw_log_res_10_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*10,0), 0))', '_tr_fw_sqrt_res_10_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*10,0), 0))', '_tr_fw_log_res_10_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*10,0), 0))', '_tr_fw_sqrt_res_50_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*50,0), 0))', '_tr_fw_log_res_50_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*50,0), 0))', '_tr_fw_log_res_50_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*50,0), 0))', '_tr_fw_log_res_50_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*50,0), 0))', '_tr_fw_log_res_50_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*50,0), 0))', '_tr_fw_log_res_50_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*50,0), 0))', '_tr_fw_log_res_50_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*50,0), 0))', '_tr_fw_log_res_50_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*50,0), 0))', '_tr_fw_sqrt_res_50_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*50,0), 0))', '_tr_fw_log_res_50_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*50,0), 0))', '_tr_fw_sqrt_res_100_gt_1': 'np.where(X < 1, X, np.where(X>1 ,np.round(np.sqrt(X-1)*100,0), 0))', '_tr_fw_log_res_100_gt_1': 'np.where(X <1, X, np.where(X >1, np.round(np.log(X-1)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_2': 'np.where(X < 2, X, np.where(X>2 ,np.round(np.sqrt(X-2)*100,0), 0))', '_tr_fw_log_res_100_gt_2': 'np.where(X <2, X, np.where(X >2, np.round(np.log(X-2)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_4': 'np.where(X < 4, X, np.where(X>4 ,np.round(np.sqrt(X-4)*100,0), 0))', '_tr_fw_log_res_100_gt_4': 'np.where(X <4, X, np.where(X >4, np.round(np.log(X-4)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_8': 'np.where(X < 8, X, np.where(X>8 ,np.round(np.sqrt(X-8)*100,0), 0))', '_tr_fw_log_res_100_gt_8': 'np.where(X <8, X, np.where(X >8, np.round(np.log(X-8)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_16': 'np.where(X < 16, X, np.where(X>16 ,np.round(np.sqrt(X-16)*100,0), 0))', '_tr_fw_log_res_100_gt_16': 'np.where(X <16, X, np.where(X >16, np.round(np.log(X-16)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_32': 'np.where(X < 32, X, np.where(X>32 ,np.round(np.sqrt(X-32)*100,0), 0))', '_tr_fw_log_res_100_gt_32': 'np.where(X <32, X, np.where(X >32, np.round(np.log(X-32)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_64': 'np.where(X < 64, X, np.where(X>64 ,np.round(np.sqrt(X-64)*100,0), 0))', '_tr_fw_log_res_100_gt_64': 'np.where(X <64, X, np.where(X >64, np.round(np.log(X-64)*100,0), 0))', '_tr_fw_sqrt_res_100_gt_96': 'np.where(X < 96, X, np.where(X>96 ,np.round(np.sqrt(X-96)*100,0), 0))', '_tr_fw_log_res_100_gt_96': 'np.where(X <96, X, np.where(X >96, np.round(np.log(X-96)*100,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*1,0), 0))', '_tr_fw_prob_sqrt_res_1_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*1,0), 0))', '_tr_fw_prob_log_res_1_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*1,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*10,0), 0))', '_tr_fw_prob_sqrt_res_10_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*10,0), 0))', '_tr_fw_prob_log_res_10_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*10,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*50,0), 0))', '_tr_fw_prob_sqrt_res_50_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*50,0), 0))', '_tr_fw_prob_log_res_50_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*50,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.01': 'np.where(X < 0.01, X, np.where(X>0.01, np.round(np.sqrt(X-0.01)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.01': 'np.where(X <0.01,X, np.where(X>0.01, np.round(np.log(X-0.01)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.02': 'np.where(X < 0.02, X, np.where(X>0.02, np.round(np.sqrt(X-0.02)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.02': 'np.where(X <0.02,X, np.where(X>0.02, np.round(np.log(X-0.02)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.04': 'np.where(X < 0.04, X, np.where(X>0.04, np.round(np.sqrt(X-0.04)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.04': 'np.where(X <0.04,X, np.where(X>0.04, np.round(np.log(X-0.04)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.08': 'np.where(X < 0.08, X, np.where(X>0.08, np.round(np.sqrt(X-0.08)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.08': 'np.where(X <0.08,X, np.where(X>0.08, np.round(np.log(X-0.08)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.16': 'np.where(X < 0.16, X, np.where(X>0.16, np.round(np.sqrt(X-0.16)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.16': 'np.where(X <0.16,X, np.where(X>0.16, np.round(np.log(X-0.16)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.32': 'np.where(X < 0.32, X, np.where(X>0.32, np.round(np.sqrt(X-0.32)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.32': 'np.where(X <0.32,X, np.where(X>0.32, np.round(np.log(X-0.32)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.64': 'np.where(X < 0.64, X, np.where(X>0.64, np.round(np.sqrt(X-0.64)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.64': 'np.where(X <0.64,X, np.where(X>0.64, np.round(np.log(X-0.64)*100,0), 0))', '_tr_fw_prob_sqrt_res_100_gt_0.96': 'np.where(X < 0.96, X, np.where(X>0.96, np.round(np.sqrt(X-0.96)*100,0), 0))', '_tr_fw_prob_log_res_100_gt_0.96': 'np.where(X <0.96,X, np.where(X>0.96, np.round(np.log(X-0.96)*100,0), 0))'}"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "resolution_range", "kind": "variable", "doc": "
    \n", "default_value": "[1, 10, 50, 100]"}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"fullname": "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range", "modulename": "outrank.feature_transformations.feature_transformer_vault.fw_transformers", "qualname": "greater_than_range", "kind": "variable", "doc": "
    \n", "default_value": "[1, 2, 4, 8, 16, 32, 64, 96]"}, "outrank.feature_transformations.ranking_transformers": {"fullname": "outrank.feature_transformations.ranking_transformers", "modulename": "outrank.feature_transformations.ranking_transformers", "kind": "module", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise", "kind": "class", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise.noise_preset", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerNoise.construct_new_features", "kind": "function", "doc": "
    Generate a few standard noise distributions
    \n", "signature": "(self, dataframe: pandas.core.frame.DataFrame, label_column=None):", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric", "kind": "class", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.__init__", "kind": "function", "doc": "
    \n", "signature": "(numeric_column_names: set[str], preset: str = 'default')"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.numeric_column_names", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.constructed_feature_names", "kind": "variable", "doc": "
    \n", "annotation": ": set[str]"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.max_maj_support", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.nan_prop_support", "kind": "variable", "doc": "
    \n"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.get_vals", "kind": "function", "doc": "
    \n", "signature": "(self, tmp_df: pandas.core.frame.DataFrame, col_name: str) -> Any:", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.construct_baseline_features", "kind": "function", "doc": "
    \n", "signature": "(self, dataframe: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"fullname": "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features", "modulename": "outrank.feature_transformations.ranking_transformers", "qualname": "FeatureTransformerGeneric.construct_new_features", "kind": "function", "doc": "
    \n", "signature": "(self, dataframe: Any) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, "outrank.task_generators": {"fullname": "outrank.task_generators", "modulename": "outrank.task_generators", "kind": "module", "doc": "
    \n"}, "outrank.task_generators.logger": {"fullname": "outrank.task_generators.logger", "modulename": "outrank.task_generators", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.task_generators.outrank_task_generate_data_set": {"fullname": "outrank.task_generators.outrank_task_generate_data_set", "modulename": "outrank.task_generators", "qualname": "outrank_task_generate_data_set", "kind": "function", "doc": "
    Core method for generating data sets
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.task_ranking": {"fullname": "outrank.task_ranking", "modulename": "outrank.task_ranking", "kind": "module", "doc": "
    \n"}, "outrank.task_ranking.outrank_task_conduct_ranking": {"fullname": "outrank.task_ranking.outrank_task_conduct_ranking", "modulename": "outrank.task_ranking", "qualname": "outrank_task_conduct_ranking", "kind": "function", "doc": "
    \n", "signature": "(args: Any):", "funcdef": "def"}, "outrank.task_selftest": {"fullname": "outrank.task_selftest", "modulename": "outrank.task_selftest", "kind": "module", "doc": "
    \n"}, "outrank.task_selftest.logger": {"fullname": "outrank.task_selftest.logger", "modulename": "outrank.task_selftest", "qualname": "logger", "kind": "variable", "doc": "
    \n", "default_value": "<Logger syn-logger (DEBUG)>"}, "outrank.task_selftest.conduct_self_test": {"fullname": "outrank.task_selftest.conduct_self_test", "modulename": "outrank.task_selftest", "qualname": "conduct_self_test", "kind": "function", "doc": "
    \n", "signature": "():", "funcdef": "def"}, "outrank.task_summary": {"fullname": "outrank.task_summary", "modulename": "outrank.task_summary", "kind": "module", "doc": "
    \n"}, "outrank.task_summary.outrank_task_result_summary": {"fullname": "outrank.task_summary.outrank_task_result_summary", "modulename": "outrank.task_summary", "qualname": "outrank_task_result_summary", "kind": "function", "doc": "
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.task_visualization": {"fullname": "outrank.task_visualization", "modulename": "outrank.task_visualization", "kind": "module", "doc": "
    \n"}, "outrank.task_visualization.outrank_task_visualize_results": {"fullname": "outrank.task_visualization.outrank_task_visualize_results", "modulename": "outrank.task_visualization", "qualname": "outrank_task_visualize_results", "kind": "function", "doc": "
    \n", "signature": "(args):", "funcdef": "def"}, "outrank.visualizations": {"fullname": "outrank.visualizations", "modulename": "outrank.visualizations", "kind": "module", "doc": "
    \n"}, "outrank.visualizations.ranking_visualization": {"fullname": "outrank.visualizations.ranking_visualization", "modulename": "outrank.visualizations.ranking_visualization", "kind": "module", "doc": "
    \n"}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"fullname": "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_hierarchical_clusters", "kind": "function", "doc": "
    A method for visualization of hierarchical clusters w.r.t. different linkage functions
    \n", "signature": "(\ttriplet_dataframe: pandas.core.frame.DataFrame,\toutput_folder: str,\timage_format: str = 'png',\tmax_num_clusters: int = 100) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"fullname": "outrank.visualizations.ranking_visualization.visualize_heatmap", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_heatmap", "kind": "function", "doc": "
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\timage_format: str) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"fullname": "outrank.visualizations.ranking_visualization.visualize_barplots", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_barplots", "kind": "function", "doc": "
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\treference_json: str,\timage_format: str,\tlabel: str,\theuristic: str) -> None:", "funcdef": "def"}, "outrank.visualizations.ranking_visualization.visualize_all": {"fullname": "outrank.visualizations.ranking_visualization.visualize_all", "modulename": "outrank.visualizations.ranking_visualization", "qualname": "visualize_all", "kind": "function", "doc": "
    A method for visualization of the obtained feature interaction maps.
    \n", "signature": "(\ttriplets: pandas.core.frame.DataFrame,\toutput_folder: str,\tlabel: str = '',\treference_json: str = '',\timage_format: str = 'png',\theuristic: str = 'MI') -> None:", "funcdef": "def"}}, "docInfo": {"outrank": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 234}, "outrank.algorithms": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"qualname": 2, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 9}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"qualname": 2, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 6}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 11}, "outrank.algorithms.importance_estimator": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_MI": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.numba_mi": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 23, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 18, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 21}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 204, "bases": 0, "doc": 3}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "outrank.algorithms.sketches": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 26}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 3}, "outrank.core_ranking": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"qualname": 4, "fullname": 7, "annotation": 4, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.IGNORED_VALUES": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_ranking.mixed_rank_graph": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 81, "bases": 0, "doc": 19}, "outrank.core_ranking.enrich_with_transformations": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 92, "bases": 0, "doc": 13}, "outrank.core_ranking.compute_combined_features": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 103, "bases": 0, "doc": 11}, "outrank.core_ranking.compute_expanded_multivalue_features": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 41}, "outrank.core_ranking.compute_subfeatures": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 70}, "outrank.core_ranking.include_noisy_features": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 11}, "outrank.core_ranking.compute_coverage": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 7}, "outrank.core_ranking.compute_feature_memory_consumption": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 10}, "outrank.core_ranking.compute_value_counts": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 6}, "outrank.core_ranking.compute_cardinalities": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 7}, "outrank.core_ranking.compute_bounds_increment": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 72, "bases": 0, "doc": 3}, "outrank.core_ranking.compute_batch_ranking": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 197, "bases": 0, "doc": 11}, "outrank.core_ranking.get_num_of_instances": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 15}, "outrank.core_ranking.get_grouped_df": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 12}, "outrank.core_ranking.checkpoint_importances_df": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 12}, "outrank.core_ranking.estimate_importances_minibatches": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 376, "bases": 0, "doc": 48}, "outrank.core_selftest": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.pro_tips": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 303, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.write_json_dump_to_file": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 30, "bases": 0, "doc": 3}, "outrank.core_utils.internal_hash": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 17}, "outrank.core_utils.DatasetInformationStorage": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "outrank.core_utils.DatasetInformationStorage.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 111, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.data_path": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.column_names": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.column_types": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.encoding": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.NumericFeatureSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.minimum": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.maximum": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.median": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.NominalFeatureSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "outrank.core_utils.BatchRankingSummary.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.BatchRankingSummary.step_times": {"qualname": 3, "fullname": 6, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.core_utils.display_random_tip": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "outrank.core_utils.get_dataset_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.core_utils.display_tool_name": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 10, "bases": 0, "doc": 3}, "outrank.core_utils.parse_ob_line": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 7}, "outrank.core_utils.parse_ob_line_vw": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 15}, "outrank.core_utils.parse_ob_csv_line": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 10}, "outrank.core_utils.generic_line_parser": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 13}, "outrank.core_utils.read_reference_json": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 9}, "outrank.core_utils.parse_namespace": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 9}, "outrank.core_utils.read_column_names": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 6}, "outrank.core_utils.parse_ob_vw_feature_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_ob_raw_feature_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_ob_feature_information": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 9}, "outrank.core_utils.parse_csv_with_description_information": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.parse_csv_raw": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "outrank.core_utils.extract_features_from_reference_JSON": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 10}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 100, "bases": 0, "doc": 10}, "outrank.core_utils.summarize_rare_counts": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 5}, "outrank.feature_transformations": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"qualname": 0, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 56, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 173, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"qualname": 0, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 4589, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"qualname": 2, "fullname": 10, "annotation": 0, "default_value": 4, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 47, "bases": 0, "doc": 8}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"qualname": 4, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "outrank.task_generators": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_generators.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_generators.outrank_task_generate_data_set": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 8}, "outrank.task_ranking": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_ranking.outrank_task_conduct_ranking": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "outrank.task_selftest": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_selftest.logger": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_selftest.conduct_self_test": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "outrank.task_summary": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_summary.outrank_task_result_summary": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "outrank.task_visualization": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.task_visualization.outrank_task_visualize_results": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "outrank.visualizations": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 15}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 93, "bases": 0, "doc": 3}, "outrank.visualizations.ranking_visualization.visualize_all": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 135, "bases": 0, "doc": 13}}, "length": 138, "save": true}, "index": {"qualname": {"root": {"3": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 2}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 11}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 4}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 1}, "x": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 4}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "j": {"docs": {"outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 9, "r": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 2}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}, "w": {"docs": {"outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 8}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 9}}}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 4}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}, "b": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 6}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 4}}}}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 2}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}}, "fullname": {"root": {"3": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms": {"tf": 1}, "outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_selftest": {"tf": 1}, "outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}, "outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}, "outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.4142135623730951}, "outrank.visualizations": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 138}}}}}}, "f": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}, "b": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 6}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms": {"tf": 1}, "outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 29}}}}}}}}, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "j": {"docs": {"outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 35, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 8}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "w": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.feature_ranking": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 48}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 2}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}, "w": {"docs": {"outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_summary.outrank_task_result_summary": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}}, "df": 1, "i": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 8, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 1}, "x": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}}, "df": 6}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 2}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 3}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 10}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 45}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 11}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 10}}}, "s": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking": {"tf": 1}, "outrank.core_ranking.logger": {"tf": 1}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_selftest": {"tf": 1}, "outrank.core_utils": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 68}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}}, "df": 4}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 3}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 9}}, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 4}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 11}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_selftest": {"tf": 1}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 3}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 6}}}, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 9, "r": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 9}}}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.synthetic_data_generators": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 5, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.get_dataset_info": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_csv_with_description_information": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 8}}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 7, "s": {"docs": {"outrank.visualizations": {"tf": 1}, "outrank.visualizations.ranking_visualization": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 6}}}}}}, "e": {"docs": {"outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.feature_transformations": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 23}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 8, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}, "outrank.feature_transformations.ranking_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 21}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.display_random_tip": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.display_tool_name": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.task_generators": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.4142135623730951}, "outrank.task_selftest": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}, "outrank.task_selftest.conduct_self_test": {"tf": 1}, "outrank.task_summary": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.4142135623730951}, "outrank.task_visualization": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.4142135623730951}}, "df": 12}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.task_selftest.conduct_self_test": {"tf": 1}}, "df": 1}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}}, "annotation": {"root": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 18, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1.4142135623730951}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 7}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1}}, "df": 2}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1}}, "df": 2}}}}}, "default_value": {"root": {"0": {"1": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "2": {"docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 2}, "4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "8": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}}, "df": 1}, "docs": {"outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 22.715633383201094}}, "df": 3}, "1": {"0": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8.06225774829855}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 3}, "docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 2}, "6": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {"outrank.core_utils.pro_tips": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 10.198039027185569}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 6}, "2": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.830951894845301}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 3}, "3": {"2": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "5": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "6": {"4": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "8": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "9": {"6": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"outrank.core_ranking.logger": {"tf": 1.4142135623730951}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.795831523312719}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 12.288205727444508}, "outrank.task_generators.logger": {"tf": 1.4142135623730951}, "outrank.task_selftest.logger": {"tf": 1.4142135623730951}}, "df": 10, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 5}, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 3.1622776601683795}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.74734012447073}}, "df": 3, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.logger": {"tf": 1.4142135623730951}, "outrank.task_generators.logger": {"tf": 1.4142135623730951}, "outrank.task_selftest.logger": {"tf": 1.4142135623730951}}, "df": 3}}}, "*": {"1": {"0": {"0": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.IGNORED_VALUES": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.6457513110645907}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.61895003862225}}, "df": 3}}}}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 3}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.logger": {"tf": 1}, "outrank.core_utils.pro_tips": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 16}, "outrank.task_generators.logger": {"tf": 1}, "outrank.task_selftest.logger": {"tf": 1}}, "df": 5}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "v": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "x": {"2": {"7": {"docs": {"outrank.core_utils.pro_tips": {"tf": 5.656854249492381}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 4}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 6.324555320336759}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.49468024894146}}, "df": 4}, "docs": {}, "df": 0}, "docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.449489742783178}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.795831523312719}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.130067012440755}}, "df": 3, "+": {"1": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}}}}}}, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 3.872983346207417}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "w": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}}, "df": 2}}, "b": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 2.8284271247461903}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 2.8284271247461903}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}, "x": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.4142135623730951}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2.449489742783178}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 4.58257569495584}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 23.08679276123039}}, "df": 3}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2.23606797749979}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "s": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.313708498984761}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.445523142259598}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "o": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 2}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 3.1622776601683795}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 11.74734012447073}}, "df": 3, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 16.0312195418814}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 8}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1.4142135623730951}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "p": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"outrank.core_utils.pro_tips": {"tf": 2}}, "df": 1, "r": {"docs": {"outrank.core_utils.pro_tips": {"tf": 1}}, "df": 1}}}}}}, "signature": {"root": {"0": {"0": {"5": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}, "1": {"0": {"0": {"0": {"0": {"0": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "5": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}, "docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}}, "df": 2}, "2": {"0": {"0": {"0": {"0": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "3": {"9": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2}, "outrank.core_utils.parse_ob_line": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 2.8284271247461903}}, "df": 7}, "docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}, "8": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 3.1622776601683795}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 5.5677643628300215}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 5.477225575051661}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 5.477225575051661}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 4.898979485566356}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 5.656854249492381}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 4.242640687119285}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 3.7416573867739413}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 4.242640687119285}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 12.806248474865697}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 5.830951894845301}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 3.4641016151377544}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 3.7416573867739413}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 4.69041575982343}, "outrank.core_ranking.mixed_rank_graph": {"tf": 8}, "outrank.core_ranking.enrich_with_transformations": {"tf": 8.54400374531753}, "outrank.core_ranking.compute_combined_features": {"tf": 9.1104335791443}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 8.246211251235321}, "outrank.core_ranking.compute_subfeatures": {"tf": 8.246211251235321}, "outrank.core_ranking.include_noisy_features": {"tf": 7.681145747868608}, "outrank.core_ranking.compute_coverage": {"tf": 7.14142842854285}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 7.14142842854285}, "outrank.core_ranking.compute_value_counts": {"tf": 5.830951894845301}, "outrank.core_ranking.compute_cardinalities": {"tf": 6}, "outrank.core_ranking.compute_bounds_increment": {"tf": 7.54983443527075}, "outrank.core_ranking.compute_batch_ranking": {"tf": 12.449899597988733}, "outrank.core_ranking.get_num_of_instances": {"tf": 4}, "outrank.core_ranking.get_grouped_df": {"tf": 6.855654600401044}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 5.830951894845301}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 17.204650534085253}, "outrank.core_utils.write_json_dump_to_file": {"tf": 4.898979485566356}, "outrank.core_utils.internal_hash": {"tf": 4}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 9.38083151964686}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 7}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 4.47213595499958}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 7.3484692283495345}, "outrank.core_utils.display_random_tip": {"tf": 3}, "outrank.core_utils.get_dataset_info": {"tf": 3.7416573867739413}, "outrank.core_utils.display_tool_name": {"tf": 3}, "outrank.core_utils.parse_ob_line": {"tf": 7.416198487095663}, "outrank.core_utils.parse_ob_line_vw": {"tf": 8.831760866327848}, "outrank.core_utils.parse_ob_csv_line": {"tf": 7.14142842854285}, "outrank.core_utils.generic_line_parser": {"tf": 8.94427190999916}, "outrank.core_utils.read_reference_json": {"tf": 4.69041575982343}, "outrank.core_utils.parse_namespace": {"tf": 6.082762530298219}, "outrank.core_utils.read_column_names": {"tf": 4.58257569495584}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_ob_feature_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 4.47213595499958}, "outrank.core_utils.parse_csv_raw": {"tf": 4.47213595499958}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 5}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 8.774964387392123}, "outrank.core_utils.summarize_rare_counts": {"tf": 7.211102550927978}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 6.164414002968976}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 5.744562646538029}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 6.324555320336759}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 5.656854249492381}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 5.656854249492381}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 3.1622776601683795}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 3.7416573867739413}, "outrank.task_selftest.conduct_self_test": {"tf": 2.6457513110645907}, "outrank.task_summary.outrank_task_result_summary": {"tf": 3.1622776601683795}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 3.1622776601683795}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 8.366600265340756}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 6.855654600401044}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 8.602325267042627}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 10.295630140987}}, "df": 68, "a": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.7320508075688772}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 2.449489742783178}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 3}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 2}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}}, "df": 31}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.get_dataset_info": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1}}, "df": 24}}}}, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 29}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 6, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 6}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 3}}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1.4142135623730951}}, "df": 4}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}}, "df": 5}}, "t": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 10}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_batch_ranking": {"tf": 2.6457513110645907}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 3.4641016151377544}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 2.6457513110645907}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.7320508075688772}, "outrank.core_utils.generic_line_parser": {"tf": 1.4142135623730951}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 2}, "outrank.core_utils.read_column_names": {"tf": 1.4142135623730951}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 2.23606797749979}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 2.23606797749979}}, "df": 32, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}}, "df": 13}}}, "t": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 6}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 2}}}, "s": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 9}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 3}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 6}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.4142135623730951}, "outrank.core_utils.display_random_tip": {"tf": 1}, "outrank.core_utils.display_tool_name": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 2}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1.7320508075688772}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 17}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 4}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.write_json_dump_to_file": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 5, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 2}}}}}}}}}, "x": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "f": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}}, "df": 1, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1}}, "df": 4}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.7320508075688772}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 7}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 4, "s": {"docs": {"outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 4}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "l": {"docs": {"outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {"outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}}, "df": 4}}}}}, "x": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.importance_estimator.numba_mi": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "p": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 4}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 7}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.449489742783178}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 7}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 6}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}}, "df": 4}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 2.449489742783178}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.449489742783178}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 10}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}}, "df": 7, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_value_counts": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_cardinalities": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 22}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 6}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 3}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 8}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 5}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1}, "outrank.core_utils.parse_csv_raw": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 8}}}, "f": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1}}, "df": 2}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 7}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 2.23606797749979}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 12}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0}}, "doc": {"root": {"0": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}, "1": {"2": {"5": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "5": {"1": {"2": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"outrank": {"tf": 9.219544457292887}, "outrank.algorithms": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_conditional_entropy": {"tf": 1.7320508075688772}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_MI": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_surrogate": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.numba_mi": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.sklearn_mi_adj": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.rank_features_3MR": {"tf": 1.7320508075688772}, "outrank.algorithms.importance_estimator.get_importances_estimate_nonmyopic": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.__init__": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.p": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.m": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_set": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.warmup_size": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.width": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.hll_flag": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog.HyperLogLogWCache.add": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators.generator_naive": {"tf": 1.7320508075688772}, "outrank.algorithms.synthetic_data_generators.generator_naive.generate_random_matrix": {"tf": 1.7320508075688772}, "outrank.core_ranking": {"tf": 1.7320508075688772}, "outrank.core_ranking.logger": {"tf": 1.7320508075688772}, "outrank.core_ranking.GLOBAL_CARDINALITY_STORAGE": {"tf": 1.7320508075688772}, "outrank.core_ranking.GLOBAL_RARE_VALUE_STORAGE": {"tf": 1.7320508075688772}, "outrank.core_ranking.IGNORED_VALUES": {"tf": 1.7320508075688772}, "outrank.core_ranking.HYPERLL_ERROR_BOUND": {"tf": 1.7320508075688772}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_combined_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 2.23606797749979}, "outrank.core_ranking.include_noisy_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_coverage": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_value_counts": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_cardinalities": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_bounds_increment": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_grouped_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_selftest": {"tf": 1.7320508075688772}, "outrank.core_utils": {"tf": 1.7320508075688772}, "outrank.core_utils.pro_tips": {"tf": 1.7320508075688772}, "outrank.core_utils.write_json_dump_to_file": {"tf": 1.7320508075688772}, "outrank.core_utils.internal_hash": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.data_path": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.column_names": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.column_types": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.col_delimiter": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.encoding": {"tf": 1.7320508075688772}, "outrank.core_utils.DatasetInformationStorage.fw_map": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.feature_name": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.minimum": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.maximum": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.median": {"tf": 1.7320508075688772}, "outrank.core_utils.NumericFeatureSummary.num_unique": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.NominalFeatureSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary.feature_name": {"tf": 1.7320508075688772}, "outrank.core_utils.NominalFeatureSummary.num_unique": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary": {"tf": 1.4142135623730951}, "outrank.core_utils.BatchRankingSummary.__init__": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.triplet_scores": {"tf": 1.7320508075688772}, "outrank.core_utils.BatchRankingSummary.step_times": {"tf": 1.7320508075688772}, "outrank.core_utils.display_random_tip": {"tf": 1.7320508075688772}, "outrank.core_utils.get_dataset_info": {"tf": 1.7320508075688772}, "outrank.core_utils.display_tool_name": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_line": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1.4142135623730951}, "outrank.core_utils.generic_line_parser": {"tf": 1.7320508075688772}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1.4142135623730951}, "outrank.core_utils.read_column_names": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_csv_with_description_information": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_csv_raw": {"tf": 1.7320508075688772}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1.4142135623730951}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1.4142135623730951}, "outrank.core_utils.summarize_rare_counts": {"tf": 1.4142135623730951}, "outrank.feature_transformations": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.MINIMAL_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.default_transformers.DEFAULT_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.FW_TRANSFORMERS": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.resolution_range": {"tf": 1.7320508075688772}, "outrank.feature_transformations.feature_transformer_vault.fw_transformers.greater_than_range": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.noise_preset": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1.4142135623730951}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.__init__": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.numeric_column_names": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.constructed_feature_names": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.max_maj_support": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.nan_prop_support": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.get_vals": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_baseline_features": {"tf": 1.7320508075688772}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerGeneric.construct_new_features": {"tf": 1.7320508075688772}, "outrank.task_generators": {"tf": 1.7320508075688772}, "outrank.task_generators.logger": {"tf": 1.7320508075688772}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1.4142135623730951}, "outrank.task_ranking": {"tf": 1.7320508075688772}, "outrank.task_ranking.outrank_task_conduct_ranking": {"tf": 1.7320508075688772}, "outrank.task_selftest": {"tf": 1.7320508075688772}, "outrank.task_selftest.logger": {"tf": 1.7320508075688772}, "outrank.task_selftest.conduct_self_test": {"tf": 1.7320508075688772}, "outrank.task_summary": {"tf": 1.7320508075688772}, "outrank.task_summary.outrank_task_result_summary": {"tf": 1.7320508075688772}, "outrank.task_visualization": {"tf": 1.7320508075688772}, "outrank.task_visualization.outrank_task_visualize_results": {"tf": 1.7320508075688772}, "outrank.visualizations": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1.4142135623730951}, "outrank.visualizations.ranking_visualization.visualize_heatmap": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_barplots": {"tf": 1.7320508075688772}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1.7320508075688772}}, "df": 138, "w": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 4}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "o": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 5, "o": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 2.449489742783178}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1.4142135623730951}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.read_column_names": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 11}, "i": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 4}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 2.6457513110645907}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 4, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}, "f": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 15}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1, "d": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 1, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 9, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.7320508075688772}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1.4142135623730951}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1.4142135623730951}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1.4142135623730951}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 26, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 3}, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 2, "d": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 3}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 1}}}}}}}}}, "|": {"docs": {}, "df": 0, "*": {"docs": {}, "df": 0, "|": {"docs": {}, "df": 0, "b": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.7320508075688772}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 13, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.7320508075688772}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 2}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 10, "a": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}, "b": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "c": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "s": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.include_noisy_features": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 8}}}}}}, "w": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 2}, "outrank.core_utils.generic_line_parser": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 3}, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 4}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 8, "d": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_coverage": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 2}}}}, "y": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 4}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "v": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1.4142135623730951}}, "df": 2}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 3, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "d": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}, "outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_combined_features": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 9}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "t": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.compute_entropies": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 4, "s": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 2}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"outrank": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_coverage": {"tf": 1}, "outrank.core_ranking.compute_cardinalities": {"tf": 1}}, "df": 3}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"outrank": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank": {"tf": 2}, "outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 5}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.compute_batch_ranking": {"tf": 1}}, "df": 2}}}}}}}}}}, "f": {"docs": {"outrank": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 2}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.parse_ob_line": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 3, "r": {"docs": {"outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 3}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}, "outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 3, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"outrank": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}, "g": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}}, "df": 1, "n": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank": {"tf": 1}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.DatasetInformationStorage": {"tf": 1}, "outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}, "outrank.core_utils.parse_ob_line": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.parse_ob_vw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_raw_feature_information": {"tf": 1}, "outrank.core_utils.parse_ob_feature_information": {"tf": 1}}, "df": 11}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.numba_unique": {"tf": 1}, "outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_value_counts": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.feature_ranking.ranking_mi_numba.mutual_info_estimator_numba": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.read_reference_json": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"outrank": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "k": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank": {"tf": 1.4142135623730951}, "outrank.core_utils.internal_hash": {"tf": 1}, "outrank.core_utils.BatchRankingSummary": {"tf": 1}}, "df": 3, "s": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.include_noisy_features": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.checkpoint_importances_df": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {"outrank": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank": {"tf": 1.4142135623730951}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {"outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"outrank.algorithms.importance_estimator.get_importances_estimate_pairwise": {"tf": 1}, "outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_utils.generic_line_parser": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}, "outrank.task_generators.outrank_task_generate_data_set": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 8}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"outrank.algorithms.sketches.counting_ultiloglog": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {"outrank": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {"outrank": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_grouped_df": {"tf": 1}, "outrank.core_ranking.checkpoint_importances_df": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_ranking.mixed_rank_graph": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_utils.read_column_names": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}, "w": {"docs": {"outrank.core_ranking.compute_feature_memory_consumption": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_utils.DatasetInformationStorage": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.internal_hash": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"outrank.core_ranking.enrich_with_transformations": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"outrank.core_ranking.get_num_of_instances": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"outrank.core_utils.NumericFeatureSummary": {"tf": 1}, "outrank.core_utils.NominalFeatureSummary": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"outrank.core_ranking.estimate_importances_minibatches": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"outrank.feature_transformations.ranking_transformers.FeatureTransformerNoise.construct_new_features": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}, "outrank.core_utils.parse_namespace": {"tf": 1}}, "df": 2}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.visualizations.ranking_visualization.visualize_hierarchical_clusters": {"tf": 1}, "outrank.visualizations.ranking_visualization.visualize_all": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1.4142135623730951}, "outrank.core_ranking.compute_subfeatures": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"outrank.core_ranking.compute_expanded_multivalue_features": {"tf": 1}, "outrank.core_ranking.compute_subfeatures": {"tf": 1}, "outrank.core_utils.summarize_rare_counts": {"tf": 1}}, "df": 3}}}}}, "w": {"docs": {"outrank.core_utils.parse_ob_line_vw": {"tf": 1}}, "df": 1}}, "x": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"outrank.core_ranking.compute_combined_features": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"outrank.core_utils.parse_ob_csv_line": {"tf": 1}, "outrank.core_utils.read_reference_json": {"tf": 1}, "outrank.core_utils.extract_features_from_reference_JSON": {"tf": 1}, "outrank.core_utils.summarize_feature_bounds_for_transformers": {"tf": 1}}, "df": 4}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
 
     // mirrored in build-search-index.js (part 1)
     // Also split on html tags. this is a cheap heuristic, but good enough.
diff --git a/setup.py b/setup.py
index 02d921a..3c83e16 100644
--- a/setup.py
+++ b/setup.py
@@ -23,7 +23,7 @@ def _read_description():
 packages = [x for x in setuptools.find_packages() if x != 'test']
 setuptools.setup(
     name='outrank',
-    version='0.92',
+    version='0.93',
     description='OutRank: Feature ranking for massive sparse data sets.',
     long_description=_read_description(),
     long_description_content_type='text/markdown',