ȅi6SSKrSSKrSSKJr SSKJr SSKrSSKJr SSKJ r SSK J r SSK J r JrJrJrJr S /r\R&1r/S Qr"S S \R,5rg) N) defaultdict)Any)nn) parametrize)type_before_parametrizations) FakeSparsityget_arg_info_from_tensor_fqnmodule_contains_param module_to_fqn swap_moduleBaseSparsifier)module module_fqn tensor_namec T^\rSrSrSrS#S\\\4S-4U4SjjjrS\\\44Sjr S\\\\\44SS4S jr S r S\\\44S jr S$S \\\4S \ 4Sjjr\4S\R"S\\\R(SS4SjjrSrSrS%S\\S4S-S\\\\S44S-4SjjrSS\4S\R"S\\\R"\\R"4S-S\ S\\R"4SjjrS$S\ SS4Sjjr\R<S\R"S \4S!j5rS"r U=r!$)&raBase class for all sparsifiers. Abstract methods that need to be implemented: - update_mask: Function to compute a new mask for all keys in the `groups`. Args: - model [nn.Module]: model to configure. The model itself is not saved but used for the state_dict saving / loading. - config [list]: configuration elements should be a dict map that includes `tensor_fqn` of tensors to sparsify - defaults [dict]: default configurations will be attached to the configuration. Only the keys that don't exist in the `config` will be updated. Example:: >>> # xdoctest: +SKIP("Can't instantiate abstract class BaseSparsifier with abstract method update_mask") >>> config = [{'tensor_fqn': 'layer1.weight', 'tensor_fqn': 'linear2.weight2', 'sparsity_level': 0.5}] >>> defaults = {'sparsity_level': 0.7} >>> # model.layer1.weight will have `sparsity_level` = 0.7 (getting default) >>> sparsifier = BaseSparsifier(config, defaults) Ndefaultsc>[TU]5 U=(d 0Ul[[5Ul/UlSUlg)NT)super__init__rrdictstategroupsenable_mask_update)selfr __class__s e/home/james-whalen/.local/lib/python3.13/site-packages/torch/ao/pruning/sparsifier/base_sparsifier.pyrBaseSparsifier.__init__7s4 (0B &1$&7 ,. "&returncJURURURS.$)Nrrrr#)rs r __getstate__BaseSparsifier.__getstate__?s! ZZkk  r rc:URRU5 gN)__dict__update)rrs r __setstate__BaseSparsifier.__setstate__Fs U#r c"URRS-n[UR5HWup#USnUS- nUSUS3- nUSUS3- n[ UR 55HnUS:XaM USUSX5S3- nM MY US- nU$) Nz (r z Group z module: z z: ))r__name__ enumeratersortedkeys)r format_stringi sparse_argsrkeys r__repr__BaseSparsifier.__repr__Is//$6 ' 4NA *F T !M xs"- -M ~fXR8 8Mk..01(?6#b1A0B"!EE 2 5  r c URVs/sH'n[[SUR555PM) nnURUS.$s snf)aSReturns the state of the optimizer as a :class:`dict`. It contains: * state - current state of the sparsification. * groups - a list containing all sparsity configuration groups with the key 'tensor_fqn' specifying the path to the sparsified tensor within a model TODO: Need a clean way of loading the state of the "prepared" module cUS[;$)Nr)KEYS_NOT_IN_STATE_DICT) key_values r+BaseSparsifier.state_dict..esil:P&Pr rr)rrfilteritemsr)rmgrs r state_dictBaseSparsifier.state_dictWs`$kk( " PHHJ  " ( ZZ  ( s.ArCstrictc [R"US5nUSnUR5GHupV[URU5nUSnUSn U(aUc[ SUS35eSn UR U Hn [U [5(dMSn O U (dI[[R"[X5R55n [R"XU 5 URS S5bUR!S 5n U W lUHn U S U:XdMU R%U5 M! GM UR'XCS .5 g) NrrrrzError loading z into the modelFTmask tensor_fqnr?)copydeepcopyrAr model RuntimeErrorparametrizations isinstancer torchonesgetattrshaperregister_parametrizationgetpoprGr)r*)rrCrErstatesrHsarg_inforrfoundprGrBs rload_state_dictBaseSparsifier.load_state_dictqs-z(34G$#\\^MJ3DJJ KHh'F"=1K&."^J<#OPPE,,[9a.. E: GF,H,N,N!OP44V!LuuVT".uuV}l#z1IIh'',, F=>r rKSUPPORTED_MODULEScf/UlU/nU(aUR5nUR5HrupV[U5U;aM[ X5n[ U[ 5(d [S5eURRSUS-05 MaURU5 Mt U(aMgg)Nzmodule_fqn must be a stringrHz.weight) configrUnamed_childrentyper rNstrAssertionErrorappend)rrKr]stackr_namechildrs rmake_config_from_model%BaseSparsifier.make_config_from_models  YY[F & 5 5 7 ;"33!.u!??t}}5J   m ,# d;J!$M $@#R ,$,1Z_D</ #&:&? ?:? R-*3%/no,   2 3 KK  z *M)N r c *URHnUSnUSnURS[5nURS[R"[ XE555nXpR USS'[R"XEU"U55 M g)z-Adds mask parametrization to the layer weightrrparametrizationrGrHN) rrTr rO ones_likerQrrrS)rargskwargsr_rrrsrGs rrlBaseSparsifier._prepareskkFH%F /K$jj):LIO::feoogf6R&STD7;JJvl+ ,V 4  0 0_T%:  "r params_to_keep.params_to_keep_per_layercnURHnUSnUSn[R"XgSS9 0nUb%UV s0sHoXY_M n n URU 5 Ub=UR USS5n U b%U V s0sHoXY_M n n URU 5 U(dMXlM gs sn fs sn f)aSquashes the sparse masks into the appropriate tensors. If either the `params_to_keep` or `params_to_keep_per_layer` is set, the module will have a `sparse_params` dict attached to it. Args: params_to_keep: List of keys to save in the module or a dict representing the modules and keys that will have sparsity parameters saved params_to_keep_per_layer: Dict to specify the params that should be saved for specific layers. The keys in the dict should be the module fqn, while the values should be a list of strings with the names of the variables to save in the `sparse_params` Examples: >>> # xdoctest: +SKIP("locals are undefined") >>> # Don't save any sparse params >>> sparsifier.squash_mask() >>> hasattr(model.submodule1, "sparse_params") False >>> # Keep sparse params per layer >>> sparsifier.squash_mask( ... params_to_keep_per_layer={ ... "submodule1.linear1": ("foo", "bar"), ... "submodule2.linear42": ("baz",), ... } ... ) >>> print(model.submodule1.linear1.sparse_params) {'foo': 42, 'bar': 24} >>> print(model.submodule2.linear42.sparse_params) {'baz': 0.1} >>> # Keep sparse params for all layers >>> sparsifier.squash_mask(params_to_keep=("foo", "bar")) >>> print(model.submodule1.linear1.sparse_params) {'foo': 42, 'bar': 24} >>> print(model.submodule2.linear42.sparse_params) {'foo': 42, 'bar': 24} >>> # Keep some sparse params for all layers, and specific ones for >>> # some other layers >>> sparsifier.squash_mask( ... params_to_keep=("foo", "bar"), ... params_to_keep_per_layer={"submodule2.linear42": ("baz",)}, ... ) >>> print(model.submodule1.linear1.sparse_params) {'foo': 42, 'bar': 24} >>> print(model.submodule2.linear42.sparse_params) {'foo': 42, 'bar': 24, 'baz': 0.1} rrT)leave_parametrizedNr)rrremove_parametrizationsr)rT sparse_params) rrxryrurvr_rrr}k global_paramsparamsper_layer_paramss r squash_maskBaseSparsifier.squash_masksvkkFH%F /K  / / M)7E F~!FI~ F$$]3'3155f\6JDQ%>D'Ef69 f$'E!(()9:}'4$#"!G (Fs B-8B2FrmappinginplaceparameterizationcdUc [S5eU(d[R"U5n0nUR5HGupg[ Xt5(a[ U5U;a[ Xr5XV'M3URUUSUS9XV'MI UR5HupXRU'M U$)aConverts submodules in input module to a different module according to `mapping` by calling `from_dense` method on the target module class Args: module: input module mapping: a dictionary that maps from source module type to target module type, can be overwritten to allow swapping user defined Modules inplace: carry out model transformations in-place, the original module is mutated zNeed to auto generate mapping T)rrr) NotImplementedErrorrIrJr`r rr convertrA_modules) rrrrrreassignnamemodr6values rrBaseSparsifier.convert2s" ?%&FG G]]6*F..0ID&c<<05@!,S!:"&# %5 "."1 #..*JC#(OOC + r use_pathcUR(dg[R"5 URHnUR"S0UD6 M SSS5 g!,(df  g=f)N)rrOno_gradr update_mask)rrr_s rstepBaseSparsifier.step^s@&&  ]]_++  *6*&__s &A A%rc gr'r)rrrrvs rrBaseSparsifier.update_maskes r )r_rrrrKrr')T)NN)"r/ __module__ __qualname____firstlineno____doc__rrbrrr$r*r7rCboolr[r]rModulesetraLinearrhrprltuplerr rrabcabstractmethodr__static_attributes__ __classcell__)rs@rrrs2'c3h$!6'' d38n $$sDcN':";$$  DcN 4?$sCx.?$?<3D(yy(tBII/(  ($8t 26FJL5c3h$.L5#'sE#s(O';"* * ryy/ *X+T+T+  ")) #  r )rrI collectionsrtypingrrOrtorch.nn.utilsrtorch.nn.utils.parametrizerutilsr r r r r __all__rr]r;ABCrrr rrsU # &C  YYK@J SWWJ r