8137716344

Committed 22 Jan 2024 10:53PM UTC coverage: 98.47%. Remained the same

Build # 8137716344

Build Type

push

github

Committed by

web-flow

Commit Message

Bump pillow from 10.1.0 to 10.2.0 in /tests (#718)

Bumps [pillow](https://github.com/python-pillow/Pillow) from 10.1.0 to 10.2.0.
- [Release notes](https://github.com/python-pillow/Pillow/releases)
- [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst)
- [Commits](https://github.com/python-pillow/Pillow/compare/10.1.0...10.2.0)

---
updated-dependencies:
- dependency-name: pillow
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

3475 of 3529 relevant lines covered (98.47%)

7.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/foolbox/attacks/basic_iterative_method.py

from typing import Optional

from .gradient_descent_base import L1BaseGradientDescent
from .gradient_descent_base import L2BaseGradientDescent
from .gradient_descent_base import LinfBaseGradientDescent
from .gradient_descent_base import AdamOptimizer, Optimizer
import eagerpy as ep


class L1BasicIterativeAttack(L1BaseGradientDescent):
    """L1 Basic Iterative Method

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )


class L2BasicIterativeAttack(L2BaseGradientDescent):
    """L2 Basic Iterative Method

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )


class LinfBasicIterativeAttack(LinfBaseGradientDescent):
    """L-infinity Basic Iterative Method

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )


class L1AdamBasicIterativeAttack(L1BaseGradientDescent):
    """L1 Basic Iterative Method with Adam optimizer

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
        adam_beta1: float = 0.9,
        adam_beta2: float = 0.999,
        adam_epsilon: float = 1e-8,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )

        self.adam_beta1 = adam_beta1
        self.adam_beta2 = adam_beta2
        self.adam_epsilon = adam_epsilon


class L2AdamBasicIterativeAttack(L2BaseGradientDescent):
    """L2 Basic Iterative Method with Adam optimizer

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
        adam_beta1: float = 0.9,
        adam_beta2: float = 0.999,
        adam_epsilon: float = 1e-8,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )

        self.adam_beta1 = adam_beta1
        self.adam_beta2 = adam_beta2
        self.adam_epsilon = adam_epsilon


class LinfAdamBasicIterativeAttack(LinfBaseGradientDescent):
    """L-infinity Basic Iterative Method with Adam optimizer

    Args:
        rel_stepsize: Stepsize relative to epsilon.
        abs_stepsize: If given, it takes precedence over rel_stepsize.
        steps : Number of update steps.
        random_start : Controls whether to randomly start within allowed epsilon ball.
    """

    def __init__(
        self,
        *,
        rel_stepsize: float = 0.2,
        abs_stepsize: Optional[float] = None,
        steps: int = 10,
        random_start: bool = False,
        adam_beta1: float = 0.9,
        adam_beta2: float = 0.999,
        adam_epsilon: float = 1e-8,
    ):
        super().__init__(
            rel_stepsize=rel_stepsize,
            abs_stepsize=abs_stepsize,
            steps=steps,
            random_start=random_start,
        )

        self.adam_beta1 = adam_beta1
        self.adam_beta2 = adam_beta2
        self.adam_epsilon = adam_epsilon

    def get_optimizer(self, x: ep.Tensor, stepsize: float) -> Optimizer:
        return AdamOptimizer(
            x,
            stepsize,
            self.adam_beta1,
            self.adam_beta2,
            self.adam_epsilon,
        )

1	from typing import Optional	10✔
2
3	from .gradient_descent_base import L1BaseGradientDescent	10✔
4	from .gradient_descent_base import L2BaseGradientDescent	10✔
5	from .gradient_descent_base import LinfBaseGradientDescent	10✔
6	from .gradient_descent_base import AdamOptimizer, Optimizer	10✔
7	import eagerpy as ep	10✔
8
9
10	class L1BasicIterativeAttack(L1BaseGradientDescent):	10✔
11	"""L1 Basic Iterative Method
12
13	Args:
14	rel_stepsize: Stepsize relative to epsilon.
15	abs_stepsize: If given, it takes precedence over rel_stepsize.
16	steps : Number of update steps.
17	random_start : Controls whether to randomly start within allowed epsilon ball.
18	"""
19
20	def __init__(	10✔
21	self,
22	*,
23	rel_stepsize: float = 0.2,
24	abs_stepsize: Optional[float] = None,
25	steps: int = 10,
26	random_start: bool = False,
27	):
28	super().__init__(	10✔
29	rel_stepsize=rel_stepsize,
30	abs_stepsize=abs_stepsize,
31	steps=steps,
32	random_start=random_start,
33	)
34
35
36	class L2BasicIterativeAttack(L2BaseGradientDescent):	10✔
37	"""L2 Basic Iterative Method
38
39	Args:
40	rel_stepsize: Stepsize relative to epsilon.
41	abs_stepsize: If given, it takes precedence over rel_stepsize.
42	steps : Number of update steps.
43	random_start : Controls whether to randomly start within allowed epsilon ball.
44	"""
45
46	def __init__(	10✔
47	self,
48	*,
49	rel_stepsize: float = 0.2,
50	abs_stepsize: Optional[float] = None,
51	steps: int = 10,
52	random_start: bool = False,
53	):
54	super().__init__(	10✔
55	rel_stepsize=rel_stepsize,
56	abs_stepsize=abs_stepsize,
57	steps=steps,
58	random_start=random_start,
59	)
60
61
62	class LinfBasicIterativeAttack(LinfBaseGradientDescent):	10✔
63	"""L-infinity Basic Iterative Method
64
65	Args:
66	rel_stepsize: Stepsize relative to epsilon.
67	abs_stepsize: If given, it takes precedence over rel_stepsize.
68	steps : Number of update steps.
69	random_start : Controls whether to randomly start within allowed epsilon ball.
70	"""
71
72	def __init__(	10✔
73	self,
74	*,
75	rel_stepsize: float = 0.2,
76	abs_stepsize: Optional[float] = None,
77	steps: int = 10,
78	random_start: bool = False,
79	):
80	super().__init__(	10✔
81	rel_stepsize=rel_stepsize,
82	abs_stepsize=abs_stepsize,
83	steps=steps,
84	random_start=random_start,
85	)
86
87
88	class L1AdamBasicIterativeAttack(L1BaseGradientDescent):	10✔
89	"""L1 Basic Iterative Method with Adam optimizer
90
91	Args:
92	rel_stepsize: Stepsize relative to epsilon.
93	abs_stepsize: If given, it takes precedence over rel_stepsize.
94	steps : Number of update steps.
95	random_start : Controls whether to randomly start within allowed epsilon ball.
96	"""
97
98	def __init__(	10✔
99	self,
100	*,
101	rel_stepsize: float = 0.2,
102	abs_stepsize: Optional[float] = None,
103	steps: int = 10,
104	random_start: bool = False,
105	adam_beta1: float = 0.9,
106	adam_beta2: float = 0.999,
107	adam_epsilon: float = 1e-8,
108	):
109	super().__init__(	10✔
110	rel_stepsize=rel_stepsize,
111	abs_stepsize=abs_stepsize,
112	steps=steps,
113	random_start=random_start,
114	)
115
116	self.adam_beta1 = adam_beta1	10✔
117	self.adam_beta2 = adam_beta2	10✔
118	self.adam_epsilon = adam_epsilon	10✔
119
120
121	class L2AdamBasicIterativeAttack(L2BaseGradientDescent):	10✔
122	"""L2 Basic Iterative Method with Adam optimizer
123
124	Args:
125	rel_stepsize: Stepsize relative to epsilon.
126	abs_stepsize: If given, it takes precedence over rel_stepsize.
127	steps : Number of update steps.
128	random_start : Controls whether to randomly start within allowed epsilon ball.
129	"""
130
131	def __init__(	10✔
132	self,
133	*,
134	rel_stepsize: float = 0.2,
135	abs_stepsize: Optional[float] = None,
136	steps: int = 10,
137	random_start: bool = False,
138	adam_beta1: float = 0.9,
139	adam_beta2: float = 0.999,
140	adam_epsilon: float = 1e-8,
141	):
142	super().__init__(	10✔
143	rel_stepsize=rel_stepsize,
144	abs_stepsize=abs_stepsize,
145	steps=steps,
146	random_start=random_start,
147	)
148
149	self.adam_beta1 = adam_beta1	10✔
150	self.adam_beta2 = adam_beta2	10✔
151	self.adam_epsilon = adam_epsilon	10✔
152
153
154	class LinfAdamBasicIterativeAttack(LinfBaseGradientDescent):	10✔
155	"""L-infinity Basic Iterative Method with Adam optimizer
156
157	Args:
158	rel_stepsize: Stepsize relative to epsilon.
159	abs_stepsize: If given, it takes precedence over rel_stepsize.
160	steps : Number of update steps.
161	random_start : Controls whether to randomly start within allowed epsilon ball.
162	"""
163
164	def __init__(	10✔
165	self,
166	*,
167	rel_stepsize: float = 0.2,
168	abs_stepsize: Optional[float] = None,
169	steps: int = 10,
170	random_start: bool = False,
171	adam_beta1: float = 0.9,
172	adam_beta2: float = 0.999,
173	adam_epsilon: float = 1e-8,
174	):
175	super().__init__(	10✔
176	rel_stepsize=rel_stepsize,
177	abs_stepsize=abs_stepsize,
178	steps=steps,
179	random_start=random_start,
180	)
181
182	self.adam_beta1 = adam_beta1	10✔
183	self.adam_beta2 = adam_beta2	10✔
184	self.adam_epsilon = adam_epsilon	10✔
185
186	def get_optimizer(self, x: ep.Tensor, stepsize: float) -> Optimizer:	10✔
187	return AdamOptimizer(	6✔
188	x,
189	stepsize,
190	self.adam_beta1,
191	self.adam_beta2,
192	self.adam_epsilon,
193	)

bethgelab / foolbox / 8137716344

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous