Skip to content

missingness

EdgesMissingCompletelyAtRandom

Bases: MissingGenerator

Removes edges from the graph uniformly at random.

Source code in badgers/generators/graph/missingness.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
class EdgesMissingCompletelyAtRandom(MissingGenerator):
    """
    Removes edges from the graph uniformly at random.
    """

    def __init__(self, percentage_missing: int = 10, random_generator: numpy.random.Generator = default_rng(seed=0)):
        super().__init__(percentage_missing=percentage_missing, random_generator=random_generator)

    def generate(self, X, y=None, **params) -> Tuple:
        if not isinstance(X, nx.Graph):
            raise NotImplementedError('badgers does only support networkx.Graph objects for graphs')

        edges_to_be_removed = self.random_generator.choice(
            X.edges(),
            int(X.number_of_edges() * self.percentage_missing / 100),
            replace=False
        )

        Xt = X.copy()
        Xt.remove_edges_from(edges_to_be_removed)

        if y is None:
            yt = None
        elif isinstance(y, dict):
            yt = copy(y)
            for e in edges_to_be_removed:
                del yt[e]
        else:
            raise ValueError(f'This type of y is not supported {type(y)}, {y}')

        return Xt, yt

MissingGenerator

Bases: GeneratorMixin

Base class for missing nodes transformer

Source code in badgers/generators/graph/missingness.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class MissingGenerator(GeneratorMixin):
    """
    Base class for missing nodes transformer
    """

    def __init__(self, percentage_missing: int = 10, random_generator: numpy.random.Generator = default_rng(seed=0)):
        """

        :param percentage_missing: The percentage of missing nodes (int value between 0 and 100 included)
        :param random_generator: A random generator
        """
        assert 0 <= percentage_missing <= 100
        self.percentage_missing = percentage_missing
        self.random_generator = random_generator

    @abc.abstractmethod
    def generate(self, X, y=None, **params) -> Tuple:
        pass

__init__(percentage_missing=10, random_generator=default_rng(seed=0))

:param percentage_missing: The percentage of missing nodes (int value between 0 and 100 included) :param random_generator: A random generator

Source code in badgers/generators/graph/missingness.py 
18
19
20
21
22
23
24
25
26
def __init__(self, percentage_missing: int = 10, random_generator: numpy.random.Generator = default_rng(seed=0)):
    """

    :param percentage_missing: The percentage of missing nodes (int value between 0 and 100 included)
    :param random_generator: A random generator
    """
    assert 0 <= percentage_missing <= 100
    self.percentage_missing = percentage_missing
    self.random_generator = random_generator

NodesMissingCompletelyAtRandom

Bases: MissingGenerator

Removes nodes from the graph uniformly at random.

Source code in badgers/generators/graph/missingness.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class NodesMissingCompletelyAtRandom(MissingGenerator):
    """
    Removes nodes from the graph uniformly at random.
    """

    def __init__(self, percentage_missing: int = 10, random_generator: numpy.random.Generator = default_rng(seed=0)):
        super().__init__(percentage_missing=percentage_missing, random_generator=random_generator)

    def generate(self, X, y=None, **params) -> Tuple:
        if not isinstance(X, nx.Graph):
            raise NotImplementedError('badgers does only support networkx.Graph objects for graphs')

        nodes_to_be_removed = self.random_generator.choice(
            X.nodes(),
            int(X.number_of_nodes() * self.percentage_missing / 100),
            replace=False
        )

        Xt = X.copy()
        Xt.remove_nodes_from(nodes_to_be_removed)

        if y is not None:
            yt = np.delete(y, nodes_to_be_removed)
        else:
            yt = None

        return Xt, yt