.. _l-methods: Methods ======= .. contents:: :local: :depth: 1 Summary +++++++ +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | method | class parent | truncated documentation | +=========================================================================================================================+=========================+===============================================================================================================================+ | :py:meth:`__add__ ` | Point | ajoute un vecteur a celui-ci | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | Point | retourne True si les deux points ``self`` et ``a`` sont egaux, False sinon | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__eq__ ` | NeuralTreeNode | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__getitem__ ` | GraphDistance | returns a vertex or an edge if no vertex with the given index was found | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__getitem__ ` | NeuralTreeNet | Retrieves node and attributes for node i. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__getitem__ ` | CompletionSystem | Returns ``elements[i]``. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__getstate__ ` | NeuralTreeNode | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__iadd__ ` | Point | ajoute un vecteur à celui-ci | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | Edge | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | GraphDistance | constructor | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | Vertex | constructor | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | _Edge | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | _Vertex | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | InformationPoint | constructeur, initialisation | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | LigneGradient | constructeur | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | SegmentNFA | segment + nombre de fausses alarmes | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | SegmentBord_Commun | constructeur, definit la definition de l'image | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | SegmentBord | initialise les dimensions et fait sorte que la classe contienne le premier segment | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | Point | constructeur | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | Segment | constructeur, pour éviter des erreurs d'etourderie, on crée des copies des extrémités a et b, comme ce sont ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NeuralTreeNode | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NuagePoints | constructeur | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NuagePointsLaesa | Construit la classe | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | MlGridBenchMark | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | BaseNeuralTreeNet | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NeuralTreeNet | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NeuralTreeNetClassifier | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | NeuralTreeNetRegressor | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | ROC | Initialisation with a dataframe and two or three columns: | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | CompletionTrieNode | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | CompletionElement | constructor | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | CompletionSystem | fill the completion system | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | BaseOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__init__ ` | SGDOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__iter__ ` | CompletionTrieNode | Iterates on all nodes (sorted). | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__iter__ ` | CompletionSystem | Iterates over elements. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__len__ ` | LigneGradient | Retourne le nombre de pixels dans le segment, peut etre different de la liste ``self.info_ligne``, ``self.nb`` ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__len__ ` | NeuralTreeNet | Returns the number of nodes | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__len__ ` | ROC | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__len__ ` | CompletionSystem | Number of elements. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__lt__ ` | SegmentNFA | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | Edge | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | GraphDistance | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | Vertex | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | Point | usuel | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | NeuralTreeNode | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | NeuralTreeNet | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | ROC | Shows first elements, precision rate. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__repr__ ` | CompletionElement | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__setstate__ ` | NeuralTreeNode | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | Edge | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | GraphDistance | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | Vertex | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | InformationPoint | permet d'afficher cette classe | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | SegmentNFA | permet d'afficher ce segment | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | SegmentBord_Commun | permet d'afficher le segment | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | SegmentBord | permet d'afficher le segment | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | Point | permet d'afficher un point avec l'instruction print | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | Segment | permet d'afficher le segment avec l'instruction print | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | ROC | Shows first elements, precision rate. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__str__ ` | CompletionTrieNode | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`__sub__ ` | Point | soustraction de deux de vecteurs | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_add ` | CompletionTrieNode | Adds a child. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_common_loss_dloss ` | NeuralTreeNode | Common beginning to methods *loss*, *dlossds*, *dlossdw*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_common_loss_dloss ` | NeuralTreeNet | Common beginning to methods *loss*, *dlossds*, *dlossdw*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_display_progress ` | BaseOptimizer | Displays training progress. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_display_progress ` | SGDOptimizer | Displays training progress. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_evaluate_early_stopping ` | BaseOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_evaluate_early_stopping ` | SGDOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_get_output_node_attr ` | NeuralTreeNet | Retrieves the output nodes. *nb_last* is the number of expected outputs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_get_updates ` | BaseOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_get_updates ` | SGDOptimizer | Gets the values used to update params with given gradients. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_predict ` | NeuralTreeNode | Computes inputs of the activation function. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_predict_one ` | NeuralTreeNet | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_private__init__ ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_private_string_path_matching ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_regularize_gradient ` | BaseOptimizer | Applies regularization. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_regularize_gradient ` | SGDOptimizer | Applies regularization. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_set_fcts ` | NeuralTreeNode | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_update_members ` | NeuralTreeNet | Updates internal members. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`all_completions ` | CompletionTrieNode | Retrieves all completions for a node, the method does not need :meth:`precompute_stat` to be run first. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`all_mks_completions ` | CompletionTrieNode | Retrieves all completions for a node, the method assumes :meth:`precompute_stat` was run. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`angle ` | Point | retourne l'angle du vecteur | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`append ` | NeuralTreeNet | Appends a node into the graph. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`arrondi ` | Point | retourne les coordonnées arrondies à l'entier le plus proche | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`as_array ` | Point | Convertit en array. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`auc ` | ROC | Computes the area under the curve (:epkg:`AUC`). | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`auc_interval ` | ROC | Determines a confidence interval for the :epkg:`AUC` with bootstrap. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`bench_experiment ` | MlGridBenchMark | Calls meth *fit*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`calcul_bord2 ` | SegmentBord | calcule précisément la second extrémité, parcourt la demi-droite jusqu'à sortir de l'image, le dernier point est ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`calcul_vecteur ` | SegmentBord | En fonction de l'angle, calcule le vecteur direction du segment, ensuite fixe la première extrémité du segment ``self.a`` ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`calcul_vecteur_fin ` | SegmentBord | propose une seconde extrémité connaissant la première, beaucoup plus loin en conservant la meme orientation, ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`calcule_NFA ` | LigneGradient | ``ext[ij[0]]``: premier indice du segment, ``ext[ij[1]]``: dernier indice du segment, calcule le nombre ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`clean_dead_ends ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`clear ` | NeuralTreeNet | Clear all nodes | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`common_paths ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`compare_with_trie ` | CompletionSystem | Compares the results with the other implementation. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`compute_metrics ` | CompletionSystem | Computes the metric for the completion itself. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`compute_predecessor ` | GraphDistance | usual | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`compute_roc_curve ` | ROC | Computes a ROC curve with *nb* points avec nb, if *nb == -1*, there are as many as points as the data contains, ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`compute_successor ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`confusion ` | ROC | Computes the confusion matrix for a specific *score* or all if *score* is None. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`connect_root_and_leave ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | SegmentBord_Commun | Copie l'instance. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`copy ` | NeuralTreeNet | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`decision_function ` | BaseNeuralTreeNet | Returns the classification probabilities. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`decision_function ` | NeuralTreeNetClassifier | Returns the classification probabilities. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`decision_function ` | NeuralTreeNetRegressor | Returns the classification probabilities. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`decoupe_gradient ` | SegmentBord_Commun | Pour un segment donne joignant deux bords de l'image, cette fonction récupère le gradient et construit une liste ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`directeur ` | SegmentBord | retourne une copie du vecteur directeur | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`directeur ` | Segment | retourne le vecteur directeur du segment, ce vecteur est norme | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`distance ` | NuagePoints | Retourne une distance entre deux éléments. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`distance_matching_graphs_paths ` | GraphDistance | Computes an alignment between two graphs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dlossds ` | _TrainingAPI | Computes the loss derivative due to prediction error. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dlossds ` | NeuralTreeNode | Computes the loss derivative due to prediction error. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dlossds ` | NeuralTreeNet | Computes the loss derivative against the inputs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`draw_vertices_edges ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`edit_distance_path ` | GraphDistance | Tries to align two paths from two graphs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`end ` | MlGridBenchMark | nothing to do | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`enumerate_all_paths ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`enumerate_test_metric ` | CompletionSystem | Evaluates the completion set on a set of queries, the function returns a list of :class:`CompletionElement` ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`extremite ` | LigneGradient | Comptabilise les indices des extremites possibles, les pixels choisis ont un gradient de la bonne orientation. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fill_cache ` | _TrainingAPI | Creates a cache with intermediate results. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fill_cache ` | NeuralTreeNode | Creates a cache with intermediate results. ``lX`` is the results before the activation function, ``aX`` ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fill_cache ` | NeuralTreeNet | Creates a cache with intermediate results. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`find ` | CompletionTrieNode | Returns the node which holds all completions starting with a given prefix. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`find ` | CompletionSystem | Not very efficient, finds an item in a the list. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`first ` | Segment | Retourne la première extrémité. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | _TrainingAPI | Fits a neuron. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | NuagePoints | Follows sklearn API. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | NuagePointsLaesa | Follows sklearn API. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | MlGridBenchMark | Trains a model. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | BaseNeuralTreeNet | Trains the estimator. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | NeuralTreeNetClassifier | Trains the estimator. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`fit ` | NeuralTreeNetRegressor | Trains the estimator. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`get_matching_functions ` | GraphDistance | returns default matching functions between two vertices and two edges | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`get_order_vertices ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`gradient ` | _TrainingAPI | Computes the gradient in *X* knowing the expected value *y*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`gradient_backward ` | _TrainingAPI | Computes the gradient in X. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`gradient_backward ` | NeuralTreeNode | Computes the gradients at point *X*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`gradient_backward ` | NeuralTreeNet | Computes the gradient in X. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`graphs ` | MlGridBenchMark | Plots multiples graphs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`has_aligned_point ` | LigneGradient | Dit s'il existe des points alignés sur le segment. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`init_metrics ` | CompletionElement | initiate the metrics | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_edge ` | Edge | returns True | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_edge ` | Vertex | returns False | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_vertex ` | Edge | returns False | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_vertex ` | Vertex | returns True | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`items ` | CompletionTrieNode | Iterates on children, iterates on weight, key, child. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`items ` | CompletionSystem | Iterates on ``(e.value, e)``. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`items_list ` | CompletionTrieNode | All children nodes inluding itself in a list. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`iter_leaves ` | CompletionTrieNode | Iterators on leaves sorted per weight, yield weight, value. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`iteration_ends ` | BaseOptimizer | Performs update to learning rate and potentially other states at the end of an iteration. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`iteration_ends ` | SGDOptimizer | Performs updates to learning rate and potential other states at the end of an iteration. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`kneighbors ` | NuagePoints | Return the k nearest neighbors. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`label ` | NuagePoints | Retourne le label de l'object d'indice ``i``. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`last ` | Segment | Retourne la seconde extrémité. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`leaves ` | CompletionTrieNode | Iterators on leaves. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loss ` | _TrainingAPI | Computes the loss. Returns a float. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loss ` | NeuralTreeNode | Computes the loss. Returns a float. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loss ` | NeuralTreeNet | Computes the loss due to prediction error. Returns a float. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loss_regularization ` | BaseOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loss_regularization ` | SGDOptimizer | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`milieu ` | SegmentBord | Un autre segment, pour débugger le programme, choisit une orientation pour laquelle on sait que le résultat ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`min_dynamic_keystroke ` | CompletionTrieNode | Returns the dynamic minimum keystrokes for a word. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`min_dynamic_keystroke2 ` | CompletionTrieNode | Returns the modified dynamic minimum keystrokes for a word. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`min_keystroke ` | CompletionTrieNode | Returns the minimum keystrokes for a word without optimisation, this function should be used if you only have a ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`min_keystroke0 ` | CompletionTrieNode | Returns the minimum keystrokes for a word. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`next ` | SegmentBord | passe au segment suivant dans le parcours de l'image | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`next_chemin ` | LigneGradient | Retourne le couple suivant d'extrémités possibles, None, dans le cas contraire. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`normal ` | Segment | retourne le vecteur normal du segment, ce vecteur est norme | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`normalise ` | Point | normalise le vecteur, sa norme devient 1 | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`norme ` | Point | Retourne la norme. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`plot ` | ROC | Plots a :epkg:`ROC` curve. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`plot_graphs ` | MlGridBenchMark | Plots all graphs in the same graphs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`ppv ` | NuagePoints | Retourne l'élément le plus proche de obj et sa distance avec obj. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`ppv ` | NuagePointsLaesa | Retourne l'élément le plus proche de obj et sa distance avec obj, utilise la sélection à l'aide pivots | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`precision ` | ROC | Computes the precision. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`precompute_stat ` | CompletionTrieNode | Computes and stores list of completions for each node, computes *mks*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict ` | NeuralTreeNode | Computes neuron outputs. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict ` | NeuralTreeNet | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict ` | NeuralTreeNetClassifier | Returns the predicted classes. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict ` | NeuralTreeNetRegressor | Returns the predicted classes. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict_proba ` | NeuralTreeNetClassifier | Returns the classification probabilities. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`predict_score_experiment ` | MlGridBenchMark | Calls method *score*. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`premier ` | SegmentBord | définit le premier segment, horizontal, part du bord gauche | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`premier_chemin ` | LigneGradient | Retourne la premiere d'extremite possible. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`preprocess_dataset ` | MlGridBenchMark | Splits the dataset into train and test. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`private_count_left_right ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`private_kruskal_matrix ` | GraphDistance | | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`random_cloud ` | ROC | Resamples among the data. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`roc_intersect ` | ROC | The :epkg:`ROC` curve is defined by a set of points. This function interpolates those points to determine ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`roc_intersect_interval ` | ROC | Computes a confidence interval for the value returned by :meth:`roc_intersect`. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`scalaire ` | Point | Calcule le produit scalaire. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`scalairek ` | Point | Mulitplication par un scalaire. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`score ` | MlGridBenchMark | Scores a model. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`segments_significatifs ` | LigneGradient | Comptabilise le nombre de segments significatifs sur une ligne et les mémorise. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`selection_pivots ` | NuagePointsLaesa | Sélectionne *nb* pivots aléatoirements. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`sort_values ` | CompletionSystem | sort the elements by value | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`sort_weight ` | CompletionSystem | Sorts the elements by value. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`str_all_completions ` | CompletionTrieNode | Builds a string with all completions for all prefixes along the paths. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`str_all_completions ` | CompletionElement | builds a string with all completions for all prefixes along the paths, this is only available if parameter ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`str_mks ` | CompletionElement | return a string with metric information | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`str_mks0 ` | CompletionElement | return a string with metric information | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`test_metric ` | CompletionSystem | Evaluates the completion set on a set of queries, the function returns a dictionary with the aggregated metrics ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`to_dict ` | CompletionSystem | Returns a dictionary. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`to_dot ` | NeuralTreeNet | Exports the neural network into :epkg:`dot`. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`train ` | BaseOptimizer | Optimizes the coefficients. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`train ` | SGDOptimizer | Optimizes the coefficients. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`tuples ` | CompletionSystem | Iterates on ``(e.weight, e.value)``. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`unsorted_iter ` | CompletionTrieNode | Iterates on all nodes. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_coef ` | BaseOptimizer | Updates coefficients with given gradient. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_coef ` | SGDOptimizer | Updates coefficients with given gradient. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_metrics ` | CompletionElement | update the metrics | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_stat_dynamic ` | CompletionTrieNode | Must be called after :meth:`precompute_stat` and computes dynamic mks (see :ref:`Dynamic Minimum Keystroke `). ... | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_training_weights ` | _TrainingAPI | Updates weights. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_training_weights ` | NeuralTreeNode | Updates weights. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | :meth:`update_training_weights ` | NeuralTreeNet | Updates weights. | +-------------------------------------------------------------------------------------------------------------------------+-------------------------+-------------------------------------------------------------------------------------------------------------------------------+