The grad_operator module contains the main operators of ConFIG algorithm. You can use these operators to perform the ConFIG update step for your optimization problem.
ConFIG_update(
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ weight_model: WeightModel = EqualWeight(),
+ length_model: LengthModel = ProjectionLength(),
+ use_least_square: bool = True,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Performs the standard ConFIG update step.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ weight_model
+ |
+
+ WeightModel
+ |
+
+
+
+ The weight model for calculating the direction weights. +Defaults to EqualWeight(), which will make the final update gradient not biased towards any gradient. + |
+
+ EqualWeight()
+ |
+
+ length_model
+ |
+
+ LengthModel
+ |
+
+
+
+ The length model for rescaling the length of the final gradient. +Defaults to ProjectionLength(), which will project each gradient vector onto the final gradient vector to get the final length. + |
+
+ ProjectionLength()
+ |
+
+ use_least_square
+ |
+
+ bool
+ |
+
+
+
+ Whether to use the least square method for calculating the best direction.
+If set to False, we will directly calculate the pseudo-inverse of the gradient matrix. See |
+
+ True
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The final update gradient. + |
+
Examples:
+from conflictfree.grad_operator import ConFIG_update
+from conflictfree.utils import get_gradient_vector,apply_gradient_vector
+optimizer=torch.Adam(network.parameters(),lr=1e-3)
+for input_i in dataset:
+ grads=[] # we record gradients rather than losses
+ for loss_fn in loss_fns:
+ optimizer.zero_grad()
+ loss_i=loss_fn(input_i)
+ loss_i.backward()
+ grads.append(get_gradient_vector(network)) #get loss-specfic gradient
+ g_config=ConFIG_update(grads) # calculate the conflict-free direction
+ apply_gradient_vector(network) # set the condlict-free direction to the network
+ optimizer.step()
+conflictfree/grad_operator.py82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 | |
ConFIG_update_double(
+ grad_1: torch.Tensor,
+ grad_2: torch.Tensor,
+ weight_model: WeightModel = EqualWeight(),
+ length_model: LengthModel = ProjectionLength(),
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+ConFIG update for two gradients where no inverse calculation is needed.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grad_1
+ |
+
+ Tensor
+ |
+
+
+
+ The first gradient. + |
+ + required + | +
+ grad_2
+ |
+
+ Tensor
+ |
+
+
+
+ The second gradient. + |
+ + required + | +
+ weight_model
+ |
+
+ WeightModel
+ |
+
+
+
+ The weight model for calculating the direction weights. +Defaults to EqualWeight(), which will make the final update gradient not biased towards any gradient. + |
+
+ EqualWeight()
+ |
+
+ length_model
+ |
+
+ LengthModel
+ |
+
+
+
+ The length model for rescaling the length of the final gradient. +Defaults to ProjectionLength(), which will project each gradient vector onto the final gradient vector to get the final length. + |
+
+ ProjectionLength()
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The final update gradient. + |
+
Examples:
+from conflictfree.grad_operator import ConFIG_update_double
+from conflictfree.utils import get_gradient_vector,apply_gradient_vector
+optimizer=torch.Adam(network.parameters(),lr=1e-3)
+for input_i in dataset:
+ grads=[] # we record gradients rather than losses
+ for loss_fn in [loss_fn1, loss_fn2]:
+ optimizer.zero_grad()
+ loss_i=loss_fn(input_i)
+ loss_i.backward()
+ grads.append(get_gradient_vector(network)) #get loss-specfic gradient
+ g_config=ConFIG_update_double(grads) # calculate the conflict-free direction
+ apply_gradient_vector(network) # set the condlict-free direction to the network
+ optimizer.step()
+conflictfree/grad_operator.py11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +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 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 | |
+ Bases: GradientOperator
Operator for the ConFIG algorithm.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ weight_model
+ |
+
+ WeightModel
+ |
+
+
+
+ The weight model for calculating the direction weights. +Defaults to EqualWeight(), which will make the final update gradient not biased towards any gradient. + |
+
+ EqualWeight()
+ |
+
+ length_model
+ |
+
+ LengthModel
+ |
+
+
+
+ The length model for rescaling the length of the final gradient. +Defaults to ProjectionLength(), which will project each gradient vector onto the final gradient vector to get the final length. + |
+
+ ProjectionLength()
+ |
+
+ allow_simplified_model
+ |
+
+ bool
+ |
+
+
+
+ Whether to allow simplified model for calculating the gradient. +If set to True, will use simplified form of ConFIG method when there are only two losses (ConFIG_update_double). Defaults to True. + |
+
+ True
+ |
+
+ use_least_square
+ |
+
+ bool
+ |
+
+
+
+ Whether to use the least square method for calculating the best direction.
+If set to False, we will directly calculate the pseudo-inverse of the gradient matrix. See |
+
+ True
+ |
+
Examples:
+from conflictfree.grad_operator import ConFIGOperator
+from conflictfree.utils import get_gradient_vector,apply_gradient_vector
+optimizer=torch.Adam(network.parameters(),lr=1e-3)
+operator=ConFIGOperator() # initialize operator
+for input_i in dataset:
+ grads=[]
+ for loss_fn in loss_fns:
+ optimizer.zero_grad()
+ loss_i=loss_fn(input_i)
+ loss_i.backward()
+ grads.append(get_gradient_vector(network))
+ g_config=operator.calculate_gradient(grads) # calculate the conflict-free direction
+ apply_gradient_vector(network) # or simply use `operator.update_gradient(network,grads)` to calculate and set the condlict-free direction to the network
+ optimizer.step()
+conflictfree/grad_operator.py205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 | |
instance-attribute
+
+
+¤allow_simplified_model = allow_simplified_model
+instance-attribute
+
+
+¤use_least_square = use_least_square
+update_gradient(
+ network: torch.nn.Module,
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> None
+Calculate the gradient and apply the gradient to the network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The target network. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/grad_operator.py181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 | |
__init__(
+ weight_model: WeightModel = EqualWeight(),
+ length_model: LengthModel = ProjectionLength(),
+ allow_simplified_model: bool = True,
+ use_least_square: bool = True,
+)
+conflictfree/grad_operator.py240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 | |
calculate_gradient(
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the gradient using the ConFIG algorithm.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient. + |
+
conflictfree/grad_operator.py253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 | |
+ Bases: GradientOperator
PCGradOperator class represents a gradient operator for PCGrad algorithm.
+@inproceedings{yu2020gradient, +title={Gradient surgery for multi-task learning}, +author={Yu, Tianhe and Kumar, Saurabh and Gupta, Abhishek and Levine, Sergey and Hausman, Karol and Finn, Chelsea}, +booktitle={34th International Conference on Neural Information Processing Systems}, +year={2020}, +url={https://dl.acm.org/doi/abs/10.5555/3495724.3496213} +}
+ + + + + + +conflictfree/grad_operator.py291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 | |
__init__()
+conflictfree/grad_operator.py154 +155 | |
update_gradient(
+ network: torch.nn.Module,
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> None
+Calculate the gradient and apply the gradient to the network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The target network. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/grad_operator.py181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 | |
calculate_gradient(
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the gradient using the PCGrad algorithm.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ This parameter should not be set for current operator. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient using PCGrad method. + |
+
conflictfree/grad_operator.py305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 | |
+ Bases: GradientOperator
PCGradOperator class represents a gradient operator for IMTL-G algorithm.
+@inproceedings{ +liu2021towards, +title={Towards Impartial Multi-task Learning}, +author={Liyang Liu and Yi Li and Zhanghui Kuang and Jing-Hao Xue and Yimin Chen and Wenming Yang and Qingmin Liao and Wayne Zhang}, +booktitle={International Conference on Learning Representations}, +year={2021}, +url={https://openreview.net/forum?id=IMPnRXEWpvr} +}
+ + + + + + +conflictfree/grad_operator.py335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 | |
__init__()
+conflictfree/grad_operator.py154 +155 | |
update_gradient(
+ network: torch.nn.Module,
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> None
+Calculate the gradient and apply the gradient to the network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The target network. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/grad_operator.py181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 | |
calculate_gradient(
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the gradient using the IMTL-G algorithm.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ This parameter should not be set for current operator. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient using IMTL-G method. + |
+
conflictfree/grad_operator.py350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 | |
A base class that represents a gradient operator.
+ + +Methods:
+| Name | +Description | +
|---|---|
calculate_gradient |
+
+
+
+ Calculates the gradient based on the given gradients and losses. + |
+
update_gradient |
+
+
+
+ Updates the gradient of the network based on the calculated gradient. + |
+
conflictfree/grad_operator.py144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 | |
__init__()
+conflictfree/grad_operator.py154 +155 | |
calculate_gradient(
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the gradient based on the given gradients and losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient. + |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ If the method is not implemented. + |
+
conflictfree/grad_operator.py157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 | |
update_gradient(
+ network: torch.nn.Module,
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Sequence] = None,
+) -> None
+Calculate the gradient and apply the gradient to the network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The target network. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to the weight and length model. If your weight/length model doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/grad_operator.py181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 | |
The length_model module contains classes for rescaling the magnitude of the final gradient vector.
+The ProjectionLength class is the default length model for the ConFIG algorithm. You can create a custom length model by inheriting from the LengthModel class.
+ Bases: LengthModel
Rescale the length of the target vector based on the projection of the gradients on the target vector:
+conflictfree/length_model.py70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py79 +80 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the same length as the minimum gradient before projection, i.e., the minimum gradient will be the same length as the target vector.
+conflictfree/length_model.py160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py170 +171 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the same length as the maximum gradient before projection, i.e., the maximum gradient will be the same length as the target vector.
+conflictfree/length_model.py177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py187 +188 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the harmonic average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector.
+where
+The harmonic average can be used to avoid the influence of the large gradients.
+ + + + + + +conflictfree/length_model.py194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py212 +213 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the arithmetic average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector.
+where
+conflictfree/length_model.py219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py235 +236 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the geometric average of the lengths of all gradients before projection, i.e., the minimum gradient will be the same length as the target vector.
+where
+The geometric average can be used to avoid the influence of the large gradients.
+ + + + + + +conflictfree/length_model.py242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py260 +261 | |
+ Bases: _FlexibleTrackProjectionLength
Rescale the length of the target vector based on the projection of the gradients on the target vector. +All the gradients will be rescaled to the same length as the specific gradient before projection. +E.g., if the track_id is 2, then all the gradients will be rescaled to the same length as the third gradient before projection.
+conflictfree/length_model.py267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector.
+One of the |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector.
+One of the |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__(track_id: int)
+conflictfree/length_model.py279 +280 +281 | |
The base class for length model.
+ + +Methods:
+| Name | +Description | +
|---|---|
get_length |
+
+
+
+ Calculates the length based on the given parameters. + |
+
rescale_length |
+
+
+
+ Rescales the length of the target vector based on the given parameters. + |
+
conflictfree/length_model.py6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +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 +60 +61 +62 +63 +64 +65 +66 +67 | |
__init__()
+conflictfree/length_model.py15 +16 | |
get_length(
+ target_vector: Optional[torch.Tensor] = None,
+ unit_target_vector: Optional[torch.Tensor] = None,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> Union[torch.Tensor, float]
+Calculates the length based on the given parameters. Not all parameters are required.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The final update gradient vector. + |
+
+ None
+ |
+
+ unit_target_vector
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The unit vector of the target vector. + |
+
+ None
+ |
+
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Union[Tensor, float]
+ |
+
+
+
+ Union[torch.Tensor, float]: The calculated length. + |
+
conflictfree/length_model.py18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 | |
rescale_length(
+ target_vector: torch.Tensor,
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+) -> torch.Tensor
+Rescales the length of the target vector based on the given parameters. +It calls the get_length method to calculate the length and then rescales the target vector.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ target_vector
+ |
+
+ Tensor
+ |
+
+
+
+ The final update gradient vector. + |
+ + required + | +
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The rescaled target vector. + |
+
conflictfree/length_model.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | |
The loss_recorder module contains classes for recording the loss values during the optimization process.
+It is used in the momentum version of the ConFIG algorithm to record the loss values. Not every loss is calculated in a single iteration with the momentum version of the ConFIG algorithm. However, sometimes we need to know the information of all the loss values, e.g., logging and calculating length/weight model. You can create a custom loss recorder by inheriting from the LossRecorder class.
+ Bases: LossRecorder
A loss recorder return the latest losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_losses
+ |
+
+ int
+ |
+
+
+
+ The number of losses to record + |
+ + required + | +
conflictfree/loss_recorder.py69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 | |
instance-attribute
+
+
+¤current_losses = [0.0 for i in range(num_losses)]
+record_all_losses(losses: Sequence) -> list
+Records all the losses and returns the recorded losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The losses to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded losses. + |
+
conflictfree/loss_recorder.py35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | |
__init__(num_losses: int) -> None
+conflictfree/loss_recorder.py77 +78 | |
record_loss(
+ losses_indexes: Union[int, Sequence[int]],
+ losses: Union[float, Sequence],
+) -> list
+Records the given loss and returns the recorded loss.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses_indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The index of the loss. + |
+ + required + | +
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The loss to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded loss. + |
+
conflictfree/loss_recorder.py80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 | |
+ Bases: LossRecorder
A loss recorder that records the momentum of the loss.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_losses
+ |
+
+ int
+ |
+
+
+
+ The number of losses to record + |
+ + required + | +
+ betas
+ |
+
+ Union[float, Sequence[float]]
+ |
+
+
+
+ The moving average constant. + |
+
+ 0.9
+ |
+
conflictfree/loss_recorder.py100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 | |
instance-attribute
+
+
+¤current_losses = [0.0 for i in range(num_losses)]
+record_all_losses(losses: Sequence) -> list
+Records all the losses and returns the recorded losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The losses to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded losses. + |
+
conflictfree/loss_recorder.py35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | |
__init__(
+ num_losses: int,
+ betas: Union[float, Sequence[float]] = 0.9,
+)
+conflictfree/loss_recorder.py109 +110 +111 +112 +113 +114 | |
record_loss(
+ losses_indexes: Union[int, Sequence[int]],
+ losses: Union[float, Sequence],
+) -> list
+Records the given loss and returns the recorded loss.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses_indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The index of the loss. + |
+ + required + | +
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The loss to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded loss. + |
+
conflictfree/loss_recorder.py116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 | |
Base class for loss recorders.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_losses
+ |
+
+ int
+ |
+
+
+
+ The number of losses to record + |
+ + required + | +
conflictfree/loss_recorder.py4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +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 +60 +61 +62 +63 +64 +65 +66 | |
instance-attribute
+
+
+¤current_losses = [0.0 for i in range(num_losses)]
+__init__(num_losses: int) -> None
+conflictfree/loss_recorder.py12 +13 +14 | |
record_loss(
+ losses_indexes: Union[int, Sequence[int]],
+ losses: Union[float, Sequence],
+) -> list
+Records the given loss and returns the recorded losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses_indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The index of the loss. + |
+ + required + | +
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The loss to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded losses. + |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ If the method is not implemented. + |
+
conflictfree/loss_recorder.py16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 | |
record_all_losses(losses: Sequence) -> list
+Records all the losses and returns the recorded losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The losses to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded losses. + |
+
conflictfree/loss_recorder.py35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | |
The momentum_operator module contains the main operators for the momentum version ConFIG algorithm.
+ Bases: MomentumOperator
The major momentum version. +In this operator, the second momentum is estimated by a pseudo gradient based on the result of the gradient operator. +NOTE: The momentum-based operator, e.g., Adam, is not recommend when using this operator. Please consider using SGD optimizer.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_vectors
+ |
+
+ int
+ |
+
+
+
+ The number of gradient vectors. + |
+ + required + | +
+ beta_1
+ |
+
+ float
+ |
+
+
+
+ The moving average constant for the first momentum. + |
+
+ 0.9
+ |
+
+ beta_2
+ |
+
+ float
+ |
+
+
+
+ The moving average constant for the second momentum. + |
+
+ 0.999
+ |
+
+ gradient_operator
+ |
+
+ GradientOperator
+ |
+
+
+
+ The base gradient operator. Defaults to ConFIGOperator(). + |
+
+ ConFIGOperator()
+ |
+
+ loss_recorder
+ |
+
+ LossRecorder
+ |
+
+
+
+ The loss recorder object. +If you want to pass loss information to "update_gradient" method or "apply_gradient" method, you need to specify a loss recorder. Defaults to None. + |
+
+ None
+ |
+
Methods:
+| Name | +Description | +
|---|---|
calculate_gradient |
+
+
+
+ Calculates the gradient based on the given indexes, gradients, and losses. + |
+
update_gradient |
+
+
+
+ Updates the gradient of the given network with the calculated gradient. + |
+
Examples: +
from conflictfree.momentum_operator import PseudoMomentumOperator
+from conflictfree.utils import get_gradient_vector,apply_gradient_vector
+optimizer=torch.Adam(network.parameters(),lr=1e-3)
+operator=PseudoMomentumOperator(num_vector=len(loss_fns)) # initialize operator, the only difference here is we need to specify the number of gradient vectors.
+for input_i in dataset:
+ grads=[]
+ for loss_fn in loss_fns:
+ optimizer.zero_grad()
+ loss_i=loss_fn(input_i)
+ loss_i.backward()
+ grads.append(get_gradient_vector(network))
+ g_config=operator.calculate_gradient(grads) # calculate the conflict-free direction
+ apply_gradient_vector(network) # or simply use `operator.update_gradient(network,grads)` to calculate and set the condlict-free direction to the network
+ optimizer.step()
+conflictfree/momentum_operator.py140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 | |
instance-attribute
+
+
+¤gradient_operator = gradient_operator
+instance-attribute
+
+
+¤loss_recorder = loss_recorder
+update_gradient(
+ network: torch.nn.Module,
+ indexes: Union[int, Sequence[int]],
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Union[float, Sequence]] = None,
+) -> None
+Updates the gradient of the given network with the calculated gradient.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network to update the gradient. + |
+ + required + | +
+ indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The indexes of the gradient vectors and losses to be updated. +The momentum with the given indexes will be updated based on the given gradients. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to base gradient operator. If the base gradient operator doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ This method must be implemented in a subclass. + |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/momentum_operator.py111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 | |
__init__(
+ num_vectors: int,
+ beta_1: float = 0.9,
+ beta_2: float = 0.999,
+ gradient_operator: GradientOperator = ConFIGOperator(),
+ loss_recorder: Optional[LossRecorder] = None,
+) -> None
+conflictfree/momentum_operator.py179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 | |
calculate_gradient(
+ indexes: Union[int, Sequence[int]],
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Union[float, Sequence]] = None,
+) -> torch.Tensor
+Calculates the gradient based on the given indexes, gradients, and losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The indexes of the gradient vectors and losses to be updated. +The momentum with the given indexes will be updated based on the given gradients. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to base gradient operator. If the base gradient operator doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ This method must be implemented in a subclass. + |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient. + |
+
conflictfree/momentum_operator.py213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 | |
+ Bases: MomentumOperator
In this operator, each gradient has its own second gradient. The gradient operator is applied on the rescaled momentum. +NOTE: Please consider using the PseudoMomentumOperator since this operator does not give good performance according to our research. +The momentum-based operator, e.g., Adam, is not recommend when using this operator. Please consider using SGD optimizer.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_vectors
+ |
+
+ int
+ |
+
+
+
+ The number of gradient vectors. + |
+ + required + | +
+ beta_1
+ |
+
+ float
+ |
+
+
+
+ The moving average constant for the first momentum. + |
+
+ 0.9
+ |
+
+ beta_2
+ |
+
+ float
+ |
+
+
+
+ The moving average constant for the second momentum. + |
+
+ 0.999
+ |
+
+ gradient_operator
+ |
+
+ GradientOperator
+ |
+
+
+
+ The base gradient operator. Defaults to ConFIGOperator(). + |
+
+ ConFIGOperator()
+ |
+
+ loss_recorder
+ |
+
+ LossRecorder
+ |
+
+
+
+ The loss recorder object. +If you want to pass loss information to "update_gradient" method or "apply_gradient" method, you need to specify a loss recorder. Defaults to None. + |
+
+ None
+ |
+
Methods:
+| Name | +Description | +
|---|---|
calculate_gradient |
+
+
+
+ Calculates the gradient based on the given indexes, gradients, and losses. + |
+
update_gradient |
+
+
+
+ Updates the gradient of the given network with the calculated gradient. + |
+
conflictfree/momentum_operator.py269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 | |
instance-attribute
+
+
+¤gradient_operator = gradient_operator
+instance-attribute
+
+
+¤loss_recorder = loss_recorder
+update_gradient(
+ network: torch.nn.Module,
+ indexes: Union[int, Sequence[int]],
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Union[float, Sequence]] = None,
+) -> None
+Updates the gradient of the given network with the calculated gradient.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network to update the gradient. + |
+ + required + | +
+ indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The indexes of the gradient vectors and losses to be updated. +The momentum with the given indexes will be updated based on the given gradients. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to base gradient operator. If the base gradient operator doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ This method must be implemented in a subclass. + |
+
Returns:
+| Type | +Description | +
|---|---|
+ None
+ |
+
+
+
+ None + |
+
conflictfree/momentum_operator.py111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 | |
__init__(
+ num_vectors: int,
+ beta_1: float = 0.9,
+ beta_2: float = 0.999,
+ gradient_operator: GradientOperator = ConFIGOperator(),
+ loss_recorder: Optional[LossRecorder] = None,
+) -> None
+conflictfree/momentum_operator.py291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 | |
calculate_gradient(
+ indexes: Union[int, Sequence[int]],
+ grads: Union[torch.Tensor, Sequence[torch.Tensor]],
+ losses: Optional[Union[float, Sequence]] = None,
+) -> torch.Tensor
+Calculates the gradient based on the given indexes, gradients, and losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The indexes of the gradient vectors and losses to be updated. +The momentum with the given indexes will be updated based on the given gradients. + |
+ + required + | +
+ grads
+ |
+
+ Union[Tensor, Sequence[Tensor]]
+ |
+
+
+
+ The gradients to update. +It can be a stack of gradient vectors (at dim 0) or a sequence of gradient vectors. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses associated with the gradients. +The losses will be passed to base gradient operator. If the base gradient operator doesn't require loss information, +you can set this value as None. Defaults to None. + |
+
+ None
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ This method must be implemented in a subclass. + |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The calculated gradient. + |
+
conflictfree/momentum_operator.py325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 | |
+ Bases: LossRecorder
A loss recorder return the latest losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ num_losses
+ |
+
+ int
+ |
+
+
+
+ The number of losses to record + |
+ + required + | +
conflictfree/loss_recorder.py69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 | |
instance-attribute
+
+
+¤current_losses = [0.0 for i in range(num_losses)]
+record_all_losses(losses: Sequence) -> list
+Records all the losses and returns the recorded losses.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The losses to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded losses. + |
+
conflictfree/loss_recorder.py35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | |
__init__(num_losses: int) -> None
+conflictfree/loss_recorder.py77 +78 | |
record_loss(
+ losses_indexes: Union[int, Sequence[int]],
+ losses: Union[float, Sequence],
+) -> list
+Records the given loss and returns the recorded loss.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ losses_indexes
+ |
+
+ Union[int, Sequence[int]]
+ |
+
+
+
+ The index of the loss. + |
+ + required + | +
+ losses
+ |
+
+ Tensor
+ |
+
+
+
+ The loss to record. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
list |
+ list
+ |
+
+
+
+ The recorded loss. + |
+
conflictfree/loss_recorder.py80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 | |
The utils module contains utility functions for the ConFIG algorithm.
get_para_vector(network: torch.nn.Module) -> torch.Tensor
+Returns the parameter vector of the given network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network for which to compute the gradient vector. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The parameter vector of the network. + |
+
conflictfree/utils.py8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 | |
apply_para_vector(
+ network: torch.nn.Module, para_vec: torch.Tensor
+) -> None
+Applies a parameter vector to the network's parameters.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network to apply the parameter vector to. + |
+ + required + | +
+ para_vec
+ |
+
+ Tensor
+ |
+
+
+
+ The parameter vector to apply. + |
+ + required + | +
conflictfree/utils.py142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 | |
get_gradient_vector(
+ network: torch.nn.Module,
+ none_grad_mode: Literal[
+ "raise", "zero", "skip"
+ ] = "skip",
+) -> torch.Tensor
+Returns the gradient vector of the given network.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network for which to compute the gradient vector. + |
+ + required + | +
+ none_grad_mode
+ |
+
+ Literal['raise', 'zero', 'skip']
+ |
+
+
+
+ The mode to handle None gradients. default: 'skip' +- 'raise': Raise an error when the gradient of a parameter is None. +- 'zero': Replace the None gradient with a zero tensor. +- 'skip': Skip the None gradient. + The None gradient usually occurs when part of the network is not trainable (e.g., fine-tuning) +or the weight is not used to calculate the current loss (e.g., different parts of the network calculate different losses). +If all of your losses are calculated using the same part of the network, you should set none_grad_mode to 'skip'. +If your losses are calculated using different parts of the network, you should set none_grad_mode to 'zero' to ensure the gradients have the same shape. + |
+
+ 'skip'
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The gradient vector of the network. + |
+
conflictfree/utils.py29 +30 +31 +32 +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 +60 +61 +62 +63 +64 +65 +66 +67 | |
apply_gradient_vector(
+ network: torch.nn.Module,
+ grad_vec: torch.Tensor,
+ none_grad_mode: Literal["zero", "skip"] = "skip",
+ zero_grad_mode: Literal[
+ "skip", "pad_zero", "pad_value"
+ ] = "pad_value",
+) -> None
+Applies a gradient vector to the network's parameters.
+This function requires the network contains the some gradient information in order to apply the gradient vector.
+If your network does not contain the gradient information, you should consider using apply_gradient_vector_para_based function.
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network to apply the gradient vector to. + |
+ + required + | +
+ grad_vec
+ |
+
+ Tensor
+ |
+
+
+
+ The gradient vector to apply. + |
+ + required + | +
+ none_grad_mode
+ |
+
+ Literal['zero', 'skip']
+ |
+
+
+
+ The mode to handle None gradients.
+You should set this parameter to the same value as the one used in |
+
+ 'skip'
+ |
+
+ zero_grad_mode
+ |
+
+ Literal['padding', 'skip']
+ |
+
+
+
+ How to set the value of the gradient if your |
+
+ 'pad_value'
+ |
+
conflictfree/utils.py70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 | |
apply_gradient_vector_para_based(
+ network: torch.nn.Module, grad_vec: torch.Tensor
+) -> None
+Applies a gradient vector to the network's parameters.
+Please only use this function when you are sure that the length of grad_vec is the same of your network's parameters.
+This happens when you use get_gradient_vector with none_grad_mode set to 'zero'.
+Or, the 'none_grad_mode' is 'skip' but all of the parameters in your network is involved in the loss calculation.
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ network
+ |
+
+ Module
+ |
+
+
+
+ The network to apply the gradient vector to. + |
+ + required + | +
+ grad_vec
+ |
+
+ Tensor
+ |
+
+
+
+ The gradient vector to apply. + |
+ + required + | +
conflictfree/utils.py120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 | |
get_cos_similarity(
+ vector1: torch.Tensor, vector2: torch.Tensor
+) -> torch.Tensor
+Calculates the cosine angle between two vectors.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ vector1
+ |
+
+ Tensor
+ |
+
+
+
+ The first vector. + |
+ + required + | +
+ vector2
+ |
+
+ Tensor
+ |
+
+
+
+ The second vector. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The cosine angle between the two vectors. + |
+
conflictfree/utils.py158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 | |
unit_vector(
+ vector: torch.Tensor, warn_zero: bool = False
+) -> torch.Tensor
+Compute the unit vector of a given tensor.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ vector
+ |
+
+ Tensor
+ |
+
+
+
+ The input tensor. + |
+ + required + | +
+ warn_zero
+ |
+
+ bool
+ |
+
+
+
+ Whether to print a warning when the input tensor is zero. default: False + |
+
+ False
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: The unit vector of the input tensor. + |
+
conflictfree/utils.py173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 | |
estimate_conflict(gradients: torch.Tensor) -> torch.Tensor
+Estimates the degree of conflict of gradients.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ gradients
+ |
+
+ Tensor
+ |
+
+
+
+ A tensor containing gradients. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: A tensor consistent of the dot products between the sum of gradients and each sub-gradient. + |
+
conflictfree/utils.py230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 | |
Selects a slice of the source sequence in order. +Usually used for selecting loss functions/gradients/losses in momentum-based method if you want to update more tha one gradient in a single iteration.
+ + + + + + +conflictfree/utils.py261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 | |
__init__()
+conflictfree/utils.py268 +269 | |
select(
+ n: int, source_sequence: Sequence
+) -> Tuple[Sequence, Union[float, Sequence]]
+Selects a slice of the source sequence in order.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ n
+ |
+
+ int
+ |
+
+
+
+ The length of the target slice. + |
+ + required + | +
+ source_sequence
+ |
+
+ Sequence
+ |
+
+
+
+ The source sequence to select from. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ Tuple[Sequence, Union[float, Sequence]]
+ |
+
+
+
+ Tuple[Sequence,Union[float,Sequence]]: A tuple containing the indexes of the selected slice and the selected slice. + |
+
conflictfree/utils.py271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 | |
Selects a slice of the source sequence randomly. +Usually used for selecting loss functions/gradients/losses in momentum-based method if you want to update more tha one gradient in a single iteration.
+ + + + + + +conflictfree/utils.py304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 | |
select(
+ n: int, source_sequence: Sequence
+) -> Tuple[Sequence, Union[float, Sequence]]
+Selects a slice of the source sequence randomly.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ n
+ |
+
+ int
+ |
+
+
+
+ The length of the target slice. + |
+ + required + | +
+ source_sequence
+ |
+
+ Sequence
+ |
+
+
+
+ The source sequence to select from. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ Tuple[Sequence, Union[float, Sequence]]
+ |
+
+
+
+ Tuple[Sequence,Union[float,Sequence]]: A tuple containing the indexes of the selected slice and the selected slice. + |
+
conflictfree/utils.py310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 | |
has_zero(lists: Sequence) -> bool
+Check if any element in the list is zero.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ lists
+ |
+
+ Sequence
+ |
+
+
+
+ A list of elements. + |
+ + required + | +
Returns:
+| Name | Type | +Description | +
|---|---|---|
bool |
+ bool
+ |
+
+
+
+ True if any element is zero, False otherwise. + |
+
conflictfree/utils.py245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 | |
The weight_model module contains classes for calculating the direction weight of the final gradient vector.
+The EqualWeight class is the default weight model for the ConFIG algorithm. You can create a custom weight model by inheriting from the WeightModel class.
+ Bases: WeightModel
A weight model that assigns equal weights to all gradients.
+ + + + + + +conflictfree/weight_model.py29 +30 +31 +32 +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 | |
__init__()
+conflictfree/weight_model.py34 +35 | |
get_weights(
+ gradients: torch.Tensor,
+ losses: Optional[Sequence] = None,
+ device: Optional[Union[torch.device, str]] = None,
+) -> torch.Tensor
+Calculate the weights for the given gradients.
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+ + required + | +
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. Not used in this model. + |
+
+ None
+ |
+
Returns:
+| Type | +Description | +
|---|---|
+ Tensor
+ |
+
+
+
+ torch.Tensor: A tensor of equal weights for all gradients. + |
+
Raises:
+| Type | +Description | +
|---|---|
+ ValueError
+ |
+
+
+
+ If gradients is None. + |
+
conflictfree/weight_model.py37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 | |
Base class for weight models.
+ + + + + + +conflictfree/weight_model.py4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 | |
__init__()
+conflictfree/weight_model.py9 +10 | |
get_weights(
+ gradients: Optional[torch.Tensor] = None,
+ losses: Optional[Sequence] = None,
+)
+summary
+ + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
+ gradients
+ |
+
+ Optional[Tensor]
+ |
+
+
+
+ The loss-specific gradients matrix. The shape of this tensor should be (m,N) where m is the number of gradients and N is the number of elements of each gradients. + |
+
+ None
+ |
+
+ losses
+ |
+
+ Optional[Sequence]
+ |
+
+
+
+ The losses. + |
+
+ None
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ NotImplementedError
+ |
+
+
+
+ description + |
+
conflictfree/weight_model.py12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 | |
<#IGZpGtDn(E
zgGo`ReeD4$G&+sV2EeEc8iPx-7%jMw(3zC7@@fk>{l{Ks3n2-UiNFcaX*5cu5`oQ!
zuMfgxB1|};uC1+;$qBIi-)mNj*-Q`?06K&5?(ZJnEJ&I2vaqsD1po}^0Dm_pyH*Jw
zWJPvCX;rNe0C;{uzIKkSU~x-9YI