kiholee/uwca-semantic-mac
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reproducibility package: UWCA semantic multiple access (TWC submission)

Browse Source
This commit is contained in:
Ki-Ho Lee
2026-08-25 17:55:00 +09:00
commit 6a65d931f7
47 changed files with 10004 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rev2/data/e1_fair_baselines.json
Executable
+611
View File
@@ -0,0 +1,611 @@
{
"snr": [
0.0,
2.0,
4.0,
6.0,
8.0,
10.0,
12.0,
14.0,
16.0,
18.0,
20.0
],
"scenarios": {
"HIGH": {
"uwca": {
"ser": [
0.79322265625,
0.6887890625,
0.56841796875,
0.45421875,
0.3492578125,
0.27025390625,
0.207265625,
0.1657421875,
0.13703125,
0.12095703125,
0.1100390625
],
"cos": [
0.33795346930623055,
0.37925521612167357,
0.41644449681043627,
0.4479854838550091,
0.47490308076143267,
0.4951946732401848,
0.5113272194564342,
0.5240792188048363,
0.5319563418626785,
0.5371107071638107,
0.5412148103117943
]
},
"ofdma": {
"ser": [
0.86265625,
0.79513671875,
0.72,
0.6441796875,
0.5701171875,
0.508203125,
0.4517578125,
0.40755859375,
0.37095703125,
0.34736328125,
0.32875
],
"cos": [
0.29943249210715295,
0.33389897614717484,
0.36575670570135116,
0.39495515793561936,
0.4179712519049644,
0.4361314806342125,
0.45201442047953605,
0.46333996921777726,
0.4724611184000969,
0.4786807146668434,
0.48343033745884895
]
},
"sfdma": {
"ser": [
0.86451171875,
0.7958984375,
0.72001953125,
0.6443359375,
0.57337890625,
0.5067578125,
0.45134765625,
0.40892578125,
0.3776171875,
0.3498828125,
0.3262109375
],
"cos": [
0.2977725945413113,
0.33308099195361135,
0.36644414871931075,
0.39391879171133043,
0.4170221574604511,
0.43710611209273337,
0.4524139855802059,
0.46328682363033297,
0.4710295398533344,
0.47808450981974604,
0.4834167508780956
]
},
"noma": {
"ser": [
0.397890625,
0.2672265625,
0.19328125,
0.171796875,
0.1758203125,
0.18076171875,
0.1905859375,
0.20037109375,
0.2037109375,
0.20857421875,
0.21048828125
],
"cos": [
0.47271593764424324,
0.5070651569962501,
0.5199588078260422,
0.5122481778264045,
0.49796718955039976,
0.488938904106617,
0.4789886870980263,
0.4708588546514511,
0.46874344900250436,
0.4639585228264332,
0.462770057618618
]
},
"lmmse_blind": {
"ser": [
0.8617578125,
0.799921875,
0.72150390625,
0.643828125,
0.56947265625,
0.50923828125,
0.45154296875,
0.4073046875,
0.37138671875,
0.35033203125,
0.3273828125
],
"cos": [
0.2984296010434628,
0.3334098918735981,
0.36603861942887306,
0.39393075689673424,
0.41776161566376685,
0.4366233333945274,
0.45187092885375024,
0.4637425647675991,
0.4722751374542713,
0.47823858007788655,
0.48371231377124785
]
},
"lmmse_genie": {
"ser": [
0.7064453125,
0.57869140625,
0.44806640625,
0.3400390625,
0.23875,
0.17251953125,
0.124375,
0.0902734375,
0.06853515625,
0.05453125,
0.04357421875
],
"cos": [
0.3729763299226761,
0.41429273143410683,
0.4526737867295742,
0.4834487026929855,
0.512170577198267,
0.5344957360625266,
0.5517739492654801,
0.5652388066053391,
0.5750497043132782,
0.5823147013783455,
0.58900510430336
]
},
"tdma_proj": {
"ser": [
0.8651171875,
0.80091796875,
0.726015625,
0.64373046875,
0.56970703125,
0.506484375,
0.45396484375,
0.408828125,
0.36921875,
0.3469140625,
0.32806640625
],
"cos": [
0.29885986328125,
0.3340367446839809,
0.36605709329247477,
0.39507389038801194,
0.41877222195267677,
0.4366185148060322,
0.45217046469449995,
0.46392689675092696,
0.4729145887494087,
0.4781847970187664,
0.4829827207326889
]
}
},
"LOW": {
"uwca": {
"ser": [
0.86876953125,
0.80390625,
0.7337890625,
0.65740234375,
0.5919921875,
0.52013671875,
0.4721484375,
0.42322265625,
0.40064453125,
0.36935546875,
0.34853515625
],
"cos": [
0.29597470179200175,
0.33109628096222876,
0.36099798038601877,
0.3899730713665485,
0.4126627291738987,
0.43307775735855103,
0.4478067138791084,
0.4601286995410919,
0.4664891073107719,
0.47376771569252013,
0.47888876497745514
]
},
"ofdma": {
"ser": [
0.863359375,
0.79568359375,
0.7214453125,
0.642421875,
0.575625,
0.5086328125,
0.446640625,
0.40607421875,
0.37544921875,
0.3430859375,
0.32484375
],
"cos": [
0.29824803382158277,
0.3340535229444504,
0.3654038654267788,
0.3942600616812706,
0.41689895421266554,
0.4364903150498867,
0.45267546772956846,
0.4638157272338867,
0.47199389144778253,
0.4796067886054516,
0.484298942387104
]
},
"sfdma": {
"ser": [
0.861328125,
0.796875,
0.71943359375,
0.6455078125,
0.569296875,
0.50705078125,
0.44462890625,
0.41060546875,
0.37119140625,
0.34802734375,
0.324765625
],
"cos": [
0.30050423219799993,
0.33365500897169115,
0.3652912409603596,
0.3940856830775738,
0.4177810078859329,
0.4366115701198578,
0.45307490915060045,
0.46283702448010444,
0.4725301179289818,
0.47858723148703575,
0.4841072130203247
]
},
"noma": {
"ser": [
0.7743359375,
0.7134765625,
0.6685546875,
0.6380859375,
0.618828125,
0.6063671875,
0.6016015625,
0.59298828125,
0.59419921875,
0.59216796875,
0.59181640625
],
"cos": [
0.2506940153986216,
0.2522821005433798,
0.253538987711072,
0.2523435969650745,
0.2522695341706276,
0.25104541644454004,
0.2523400906473398,
0.25208909578621386,
0.2518411290645599,
0.25129005320370196,
0.25262403398752215
]
},
"lmmse_blind": {
"ser": [
0.8632421875,
0.7934765625,
0.72123046875,
0.6446875,
0.5729296875,
0.50517578125,
0.45265625,
0.4099609375,
0.37396484375,
0.3478515625,
0.33015625
],
"cos": [
0.2980802461504936,
0.335287110209465,
0.3664214126765728,
0.39368403509259225,
0.41743764773011205,
0.43701319947838785,
0.4511328709125519,
0.46285511627793313,
0.4718122765421867,
0.4787981267273426,
0.4830517227947712
]
},
"lmmse_genie": {
"ser": [
0.86291015625,
0.7972265625,
0.720625,
0.64396484375,
0.576796875,
0.50388671875,
0.45048828125,
0.410859375,
0.37306640625,
0.3459375,
0.32337890625
],
"cos": [
0.2987270838022232,
0.3340585994720459,
0.36559688225388526,
0.39470515951514246,
0.4167175969481468,
0.437459883838892,
0.45222372278571127,
0.4626065303385258,
0.472180430740118,
0.478725159317255,
0.48388352036476134
]
},
"tdma_proj": {
"ser": [
0.8632421875,
0.7973046875,
0.71634765625,
0.64626953125,
0.57171875,
0.50541015625,
0.45244140625,
0.41146484375,
0.3691015625,
0.3478125,
0.3271875
],
"cos": [
0.29940737307071685,
0.3341533626616001,
0.36738314867019656,
0.3947581851482391,
0.41644699349999426,
0.437353357821703,
0.45220112934708595,
0.46335226818919184,
0.4732473592460156,
0.4784095577895641,
0.482913865596056
]
}
},
"MIX": {
"uwca": {
"ser": [
0.84638671875,
0.77642578125,
0.69482421875,
0.6133203125,
0.5303515625,
0.46197265625,
0.40923828125,
0.36640625,
0.32798828125,
0.30064453125,
0.2868359375
],
"cos": [
0.3073283612728119,
0.34259016752243043,
0.3753962276875973,
0.4042992687225342,
0.42905311986804007,
0.4474186111986637,
0.4616049011051655,
0.4726345820724964,
0.48257728427648544,
0.48964122965931894,
0.49293914198875427
]
},
"ofdma": {
"ser": [
0.86296875,
0.7978125,
0.7214453125,
0.64078125,
0.5704296875,
0.50927734375,
0.45046875,
0.4148046875,
0.3720703125,
0.34546875,
0.32658203125
],
"cos": [
0.2996881593763828,
0.33301528945565223,
0.36559657275676727,
0.39512176558375356,
0.41771291017532347,
0.4362964195013046,
0.45225114360451696,
0.46220010906457903,
0.47270380780100824,
0.4790311701595783,
0.4835458607971668
]
},
"sfdma": {
"ser": [
0.8665625,
0.79666015625,
0.72443359375,
0.64232421875,
0.5667578125,
0.50875,
0.45208984375,
0.40546875,
0.3686328125,
0.34744140625,
0.32927734375
],
"cos": [
0.2980777567625046,
0.33418346554040906,
0.3653854741156101,
0.3952876031398773,
0.4191733206808567,
0.43588161647319795,
0.4515273554623127,
0.4639491982758045,
0.4729758943617344,
0.4787950477004051,
0.48281720593571664
]
},
"noma": {
"ser": [
0.67751953125,
0.60744140625,
0.54779296875,
0.51068359375,
0.4876953125,
0.47490234375,
0.46716796875,
0.46134765625,
0.45658203125,
0.45490234375,
0.45447265625
],
"cos": [
0.31611435264348986,
0.32969766601920125,
0.33653339073061944,
0.34149627268314364,
0.344899190813303,
0.3487969210743904,
0.34979948461055754,
0.3526943688094616,
0.354361120313406,
0.3555732563138008,
0.35504164710640906
]
},
"lmmse_blind": {
"ser": [
0.86271484375,
0.79595703125,
0.71880859375,
0.6420703125,
0.57037109375,
0.50509765625,
0.45580078125,
0.4087109375,
0.37091796875,
0.352421875,
0.326640625
],
"cos": [
0.2985852397978306,
0.3338994240760803,
0.36584676772356034,
0.39458225801587105,
0.41804412424564363,
0.43662389501929283,
0.45104776993393897,
0.4632842779159546,
0.47248409807682035,
0.4778492307662964,
0.4835035181045532
]
},
"lmmse_genie": {
"ser": [
0.83638671875,
0.75751953125,
0.669375,
0.58080078125,
0.50162109375,
0.43412109375,
0.36638671875,
0.32205078125,
0.291953125,
0.26453125,
0.244453125
],
"cos": [
0.3141723415255547,
0.35132803007960317,
0.38337485924363135,
0.41298850655555724,
0.4358947241306305,
0.45558819562196734,
0.47349897637963295,
0.48520163267850874,
0.4926259195804596,
0.5009401620924473,
0.506167941391468
]
},
"tdma_proj": {
"ser": [
0.86150390625,
0.7968359375,
0.72208984375,
0.63982421875,
0.56921875,
0.50787109375,
0.4481640625,
0.40513671875,
0.3756640625,
0.34693359375,
0.32443359375
],
"cos": [
0.2997307339310646,
0.3358344969153404,
0.36650204077363013,
0.39529991313815116,
0.41842835292220115,
0.4359996871650219,
0.4527186694741249,
0.4639644405245781,
0.47169492051005363,
0.47912489891052246,
0.48450767815113066
]
}
}
}
}
rev2/data/e2_phase_iui.json
Executable
+196
View File
@@ -0,0 +1,196 @@
{
"sigma_phi_deg": [
0,
5,
10,
15,
20,
30
],
"snr_eval": [
10.0,
20.0
],
"curves": {
"scalar_augtrain": {
"10.0": {
"ser": [
0.26923828125,
0.2685546875,
0.27525390625,
0.27935546875,
0.2933984375,
0.33353515625
],
"cos": [
0.49434818252921103,
0.4952818860113621,
0.4941158194839954,
0.4934180076420307,
0.48840575382113455,
0.47757710933685305
]
},
"20.0": {
"ser": [
0.1084765625,
0.1080078125,
0.11140625,
0.111796875,
0.112578125,
0.12888671875
],
"cos": [
0.5416895082592964,
0.5417140927910805,
0.5407627999782563,
0.540904797911644,
0.5404352927207947,
0.5352037853002548
]
}
},
"complexI_augtrain": {
"10.0": {
"ser": [
0.27505859375,
0.27115234375,
0.27126953125,
0.28126953125,
0.2905859375,
0.32849609375
],
"cos": [
0.49374089896678924,
0.4948993918299675,
0.49411537259817123,
0.49206591010093687,
0.4898021328449249,
0.4779812078177929
]
},
"20.0": {
"ser": [
0.1134375,
0.113359375,
0.11392578125,
0.1113671875,
0.1164453125,
0.1300390625
],
"cos": [
0.5397938752174377,
0.5402382054924965,
0.5402522572875023,
0.5409401589632035,
0.5399208971858025,
0.5344709008932114
]
}
},
"complexIQ_iqtrain": {
"10.0": {
"ser": [
0.2708203125,
0.26982421875,
0.27427734375,
0.28220703125,
0.29095703125,
0.33181640625
],
"cos": [
0.4952242363989353,
0.49554425284266473,
0.494214625954628,
0.49156691521406176,
0.4892462977766991,
0.47812732368707656
]
},
"20.0": {
"ser": [
0.109921875,
0.111875,
0.11259765625,
0.11376953125,
0.1150390625,
0.13318359375
],
"cos": [
0.5412762901186943,
0.5405166742205619,
0.540867666900158,
0.5394987732172012,
0.5398257005214692,
0.5339345020055771
]
}
},
"complexI_zerotrain": {
"10.0": {
"ser": [
0.2697265625,
0.2716015625,
0.27845703125,
0.286171875,
0.29109375,
0.331875
],
"cos": [
0.4953330734372139,
0.4946722063422203,
0.4931570044159889,
0.4913961146771908,
0.4892618091404438,
0.4782075408101082
]
},
"20.0": {
"ser": [
0.1097265625,
0.1112109375,
0.11009765625,
0.11314453125,
0.11447265625,
0.1271484375
],
"cos": [
0.5411131280660629,
0.540622621178627,
0.5416908550262451,
0.5399159497022629,
0.5392417126893997,
0.5353547763824463
]
}
}
},
"mask_overlap_m_real": {
"mean": 0.26302748918533325,
"max": 0.3177069127559662
},
"mask_overlap_m_iq": {
"mean": 0.2632656991481781,
"max": 0.3174257278442383
},
"csi_error": {
"h_err": [
0.0,
0.05,
0.1,
0.2
],
"uwca_ser": [
0.2739453125,
0.27005859375,
0.27060546875,
0.27416015625
],
"sfdma_ser": [
0.508515625,
0.510546875,
0.5090234375,
0.51283203125
]
}
}
rev2/data/e3_dynamic_users.json
Executable
+181
View File
@@ -0,0 +1,181 @@
{
"k": [
2,
3,
4,
5,
6,
7,
8
],
"snr_eval": [
10.0,
20.0
],
"activity": {
"10.0": [
[
0.9118359375,
0.33101536214351657
],
[
0.9060677099227905,
0.33357466995716095
],
[
0.89970703125,
0.33690863102674484
],
[
0.8868593761324882,
0.34056667000055313
],
[
0.8798437479138375,
0.3450345255434513
],
[
0.8694642865657807,
0.3481388032436371
],
[
0.8603125,
0.35211494997143744
]
],
"20.0": [
[
0.896796875,
0.34280089363455774
],
[
0.8785937488079071,
0.35016911059617994
],
[
0.86478515625,
0.3569996301829815
],
[
0.8461406251788139,
0.36452872648835183
],
[
0.827643229663372,
0.37127331241965295
],
[
0.8049330338835716,
0.37870371311903
],
[
0.780751953125,
0.38524287804961205
]
]
},
"fixed8": {
"10.0": [
[
0.8960546875,
0.3391794848442078
],
[
0.8792968752980233,
0.3480608442425728
],
[
0.85390625,
0.35765963658690453
],
[
0.8286250007152557,
0.36636610567569733
],
[
0.8018750005960464,
0.3757343140244484
],
[
0.7726897311210632,
0.3843724133074284
],
[
0.74373046875,
0.3927574257552624
]
],
"20.0": [
[
0.8806640625,
0.34932656660676004
],
[
0.8478645813465119,
0.3636595942080021
],
[
0.806015625,
0.377073904722929
],
[
0.7695312502980233,
0.3878504756093025
],
[
0.7219661456346512,
0.40071297124028205
],
[
0.6728571423888207,
0.4125585229694843
],
[
0.620732421875,
0.4240312688052654
]
]
},
"oracle": {
"2": {
"10.0": [
0.9151953125,
0.32624885395169256
],
"20.0": [
0.905078125,
0.33809939414262774
]
},
"4": {
"10.0": [
0.92490234375,
0.31790074944496155
],
"20.0": [
0.90427734375,
0.33895289853215216
]
},
"6": {
"10.0": [
0.8479557287693024,
0.361840800344944
],
"20.0": [
0.7785937511920928,
0.3879467982053757
]
},
"8": {
"10.0": [
0.73982421875,
0.39335060492157936
],
"20.0": [
0.617890625,
0.42435349345207213
]
}
}
}
rev2/data/e4_async.json
Executable
+151
View File
@@ -0,0 +1,151 @@
{
"dmax": [
0,
1,
2,
4,
8
],
"snr_eval": [
10.0,
20.0
],
"sync_trained": {
"10.0": [
[
0.2683203125,
0.49533248856663703
],
[
0.7208984375,
0.242251892760396
],
[
0.83734375,
0.15587599329650403
],
[
0.91517578125,
0.09062198633328081
],
[
0.95876953125,
0.0465814154734835
]
],
"20.0": [
[
0.10884765625,
0.5421956545114517
],
[
0.65294921875,
0.2639770006388426
],
[
0.79462890625,
0.1728138119354844
],
[
0.8930859375,
0.09787379436194897
],
[
0.94958984375,
0.048505370183847846
]
]
},
"aug_trained": {
"10.0": [
[
0.61974609375,
0.4028245759010315
],
[
0.80044921875,
0.20371038138866424
],
[
0.8644921875,
0.14209178265184164
],
[
0.91814453125,
0.08969146355986596
],
[
0.95642578125,
0.05853485576808452
]
],
"20.0": [
[
0.50931640625,
0.4357883331179619
],
[
0.7403515625,
0.22275549590587615
],
[
0.82765625,
0.15037441711872815
],
[
0.8998046875,
0.09680132243782281
],
[
0.94701171875,
0.06260592238977551
]
]
},
"ofdma": {
"10.0": [
[
0.508203125,
0.4361314806342125
],
[
0.76318359375,
0.21654599383473397
],
[
0.84802734375,
0.14174282837659122
],
[
0.91091796875,
0.08382582331076265
],
[
0.9557421875,
0.043560955775901675
]
],
"20.0": [
[
0.32919921875,
0.48276128739118573
],
[
0.68083984375,
0.23667482212185859
],
[
0.79951171875,
0.15432738859206438
],
[
0.88361328125,
0.09289443053305149
],
[
0.94376953125,
0.04812081384472549
]
]
}
}
rev2/data/e4_v2_async.json
Executable
+245
View File
@@ -0,0 +1,245 @@
{
"dmax": [
0,
1,
2,
4,
8
],
"snr_eval": [
10.0,
20.0
],
"curves": {
"uwca_uncorrected": {
"10.0": [
[
0.26302734375,
0.49663727134466173
],
[
0.72521484375,
0.24080994725227356
],
[
0.83720703125,
0.1565597005933523
],
[
0.9140234375,
0.09298811599612236
],
[
0.95828125,
0.045774847799912095
]
],
"20.0": [
[
0.1059765625,
0.5424016201496125
],
[
0.64892578125,
0.2658117674291134
],
[
0.79361328125,
0.1722280565276742
],
[
0.89083984375,
0.09743562746793032
],
[
0.94720703125,
0.051459523779340086
]
]
},
"ofdma_uncorrected": {
"10.0": [
[
0.50865234375,
0.43710263311862946
],
[
0.76029296875,
0.2157912875711918
],
[
0.8459375,
0.14081338860094547
],
[
0.9133984375,
0.08355670671910048
],
[
0.9558984375,
0.04483862698078155
]
],
"20.0": [
[
0.3259765625,
0.4835157571732998
],
[
0.68376953125,
0.23547276966273784
],
[
0.7949609375,
0.1552288055792451
],
[
0.886640625,
0.09062881361693144
],
[
0.94580078125,
0.04779002937488258
]
]
},
"uwca_corrected": {
"10.0": [
[
0.2655859375,
0.49615009009838107
],
[
0.44373046875,
0.4498268289864063
],
[
0.5089453125,
0.4324074760079384
],
[
0.578828125,
0.4135142582654953
],
[
0.6497265625,
0.38951330006122586
]
],
"20.0": [
[
0.11287109375,
0.5400555384159088
],
[
0.30025390625,
0.4892691922187805
],
[
0.38263671875,
0.46662179097533224
],
[
0.4680078125,
0.4436407870054245
],
[
0.56431640625,
0.41600462675094607
]
]
},
"ofdma_corrected": {
"10.0": [
[
0.50662109375,
0.4369038107991219
],
[
0.53580078125,
0.42834869906306267
],
[
0.55255859375,
0.42323953911662104
],
[
0.58455078125,
0.41399665489792825
],
[
0.638125,
0.3948879507184029
]
],
"20.0": [
[
0.32869140625,
0.48293048948049544
],
[
0.371953125,
0.4720873585343361
],
[
0.403359375,
0.46447199031710623
],
[
0.45724609375,
0.44948955610394475
],
[
0.53859375,
0.42527498200535774
]
]
},
"uwca_corrected_err20": {
"10.0": [
[
0.26931640625,
0.49530661895871164
],
[
0.5301953125,
0.3851976223289967
],
[
0.58978515625,
0.3633556814491749
],
[
0.65712890625,
0.33998452201485635
],
[
0.7178125,
0.3151700422167778
]
],
"20.0": [
[
0.11326171875,
0.5398727428913116
],
[
0.407734375,
0.4189111949503422
],
[
0.48626953125,
0.39070201337337496
],
[
0.56044921875,
0.3684333018958569
],
[
0.64603515625,
0.33623267963528636
]
]
}
}
}
rev2/data/e4_v3_async.json
Executable
+245
View File
@@ -0,0 +1,245 @@
{
"dmax": [
0,
1,
2,
4,
8
],
"snr_eval": [
10.0,
20.0
],
"curves": {
"uwca_uncorrected": {
"10.0": [
[
0.26302734375,
0.49663727134466173
],
[
0.72521484375,
0.24080994725227356
],
[
0.83720703125,
0.1565597005933523
],
[
0.9140234375,
0.09298811599612236
],
[
0.95828125,
0.045774847799912095
]
],
"20.0": [
[
0.1059765625,
0.5424016201496125
],
[
0.64892578125,
0.2658117674291134
],
[
0.79361328125,
0.1722280565276742
],
[
0.89083984375,
0.09743562746793032
],
[
0.94720703125,
0.051459523779340086
]
]
},
"ofdma_uncorrected": {
"10.0": [
[
0.50865234375,
0.43710263311862946
],
[
0.76029296875,
0.2157912875711918
],
[
0.8459375,
0.14081338860094547
],
[
0.9133984375,
0.08355670671910048
],
[
0.9558984375,
0.04483862698078155
]
],
"20.0": [
[
0.3259765625,
0.4835157571732998
],
[
0.68376953125,
0.23547276966273784
],
[
0.7949609375,
0.1552288055792451
],
[
0.886640625,
0.09062881361693144
],
[
0.94580078125,
0.04779002937488258
]
]
},
"uwca_corrected": {
"10.0": [
[
0.2655859375,
0.49615009009838107
],
[
0.30435546875,
0.4863732597231865
],
[
0.32873046875,
0.47999764248728755
],
[
0.37107421875,
0.46947461530566215
],
[
0.45490234375,
0.44783866554498675
]
],
"20.0": [
[
0.11287109375,
0.5400555384159088
],
[
0.14697265625,
0.5300638779997826
],
[
0.1816015625,
0.5197082979977131
],
[
0.2347265625,
0.5055944377183914
],
[
0.33798828125,
0.47965065121650696
]
]
},
"ofdma_corrected": {
"10.0": [
[
0.50662109375,
0.4369038107991219
],
[
0.53580078125,
0.42834869906306267
],
[
0.55255859375,
0.42323953911662104
],
[
0.58455078125,
0.41399665489792825
],
[
0.638125,
0.3948879507184029
]
],
"20.0": [
[
0.32869140625,
0.48293048948049544
],
[
0.371953125,
0.4720873585343361
],
[
0.403359375,
0.46447199031710623
],
[
0.45724609375,
0.44948955610394475
],
[
0.53859375,
0.42527498200535774
]
]
},
"uwca_corrected_err20": {
"10.0": [
[
0.26931640625,
0.49530661895871164
],
[
0.445234375,
0.412728616297245
],
[
0.4810546875,
0.40005304843187334
],
[
0.53046875,
0.38354199185967447
],
[
0.5988671875,
0.3615588688850403
]
],
"20.0": [
[
0.11326171875,
0.5398727428913116
],
[
0.31857421875,
0.4483929005265236
],
[
0.3642578125,
0.43187748357653616
],
[
0.4175390625,
0.41587104722857476
],
[
0.50896484375,
0.3869159772992134
]
]
}
}
}
rev2/data/e5_nonlinear.json
Executable
+247
View File
@@ -0,0 +1,247 @@
{
"snr": [
0.0,
2.0,
4.0,
6.0,
8.0,
10.0,
12.0,
14.0,
16.0,
18.0,
20.0
],
"cases": {
"NONLIN-HIGH": {
"beta_emp": 0.0061437999829649925,
"uwca": {
"ser": [
0.790390625,
0.6993359375,
0.60568359375,
0.5097265625,
0.42337890625,
0.36263671875,
0.3098046875,
0.26396484375,
0.243046875,
0.23076171875,
0.22005859375
],
"cos": [
0.3278296999633312,
0.36553969904780387,
0.39952867075800896,
0.42956090450286866,
0.4540892793238163,
0.47176132932305337,
0.486503779143095,
0.49822831645607946,
0.504666059166193,
0.5088490030169487,
0.5123565834760666
]
},
"ofdma": {
"ser": [
0.86720703125,
0.80474609375,
0.72923828125,
0.65044921875,
0.5783203125,
0.51802734375,
0.45974609375,
0.41630859375,
0.37927734375,
0.35287109375,
0.3345703125
],
"cos": [
0.29808355286717414,
0.332402256578207,
0.3646286201477051,
0.3923575595021248,
0.4157045525312424,
0.43456896290183067,
0.45029769226908684,
0.46131571754813194,
0.4703022360801697,
0.4764167308807373,
0.4811262246966362
]
},
"noma": {
"ser": [
0.77013671875,
0.712109375,
0.66578125,
0.634609375,
0.61708984375,
0.60466796875,
0.59591796875,
0.593671875,
0.59068359375,
0.5886328125,
0.58640625
],
"cos": [
0.2531153728067875,
0.2549177658557892,
0.2538824989646673,
0.2536986283957958,
0.2540162181854248,
0.2535675698518753,
0.25407157935202124,
0.25388947516679766,
0.25431982301175593,
0.2536552938073873,
0.25504677280783655
]
},
"lmmse_genie": {
"ser": [
0.86916015625,
0.80337890625,
0.73052734375,
0.65587890625,
0.5792578125,
0.5153515625,
0.46029296875,
0.4175390625,
0.37681640625,
0.35603515625,
0.33283203125
],
"cos": [
0.2973393540084362,
0.33171318054199217,
0.3636562559008598,
0.39189154386520386,
0.4159616154432297,
0.43497667729854583,
0.449855944365263,
0.461167299002409,
0.47068964451551437,
0.4762733347713947,
0.48112414956092836
]
}
},
"NONLIN-LOW": {
"beta_emp": 0.001806730404496193,
"uwca": {
"ser": [
0.8244921875,
0.7410546875,
0.66017578125,
0.57970703125,
0.50078125,
0.44056640625,
0.3893359375,
0.35234375,
0.324296875,
0.3056640625,
0.29314453125
],
"cos": [
0.3093454629182816,
0.3472594168782234,
0.37886988461017607,
0.40726904839277267,
0.43167252153158187,
0.4491182991862297,
0.4645391863584518,
0.474527428150177,
0.4819556805491447,
0.487779633551836,
0.4909189411997795
]
},
"ofdma": {
"ser": [
0.869609375,
0.80314453125,
0.72744140625,
0.651953125,
0.57908203125,
0.514296875,
0.458984375,
0.41361328125,
0.38015625,
0.35447265625,
0.33357421875
],
"cos": [
0.2971385581791401,
0.3324370531737804,
0.3640595290064812,
0.3918473927676678,
0.4165782316029072,
0.43477963089942934,
0.4495477384328842,
0.4618768581748009,
0.47005663082003596,
0.4766060091555119,
0.48131546869874
]
},
"noma": {
"ser": [
0.77365234375,
0.71427734375,
0.66837890625,
0.64001953125,
0.6203515625,
0.6087109375,
0.60255859375,
0.597265625,
0.59212890625,
0.5930078125,
0.58919921875
],
"cos": [
0.25110539749264715,
0.2537043013423681,
0.25317927345633506,
0.25191925302147866,
0.25150172002613547,
0.2508468548953533,
0.2522956795990467,
0.25112451463937757,
0.2523871362954378,
0.2514989008009434,
0.25212071448564527
]
},
"lmmse_genie": {
"ser": [
0.870390625,
0.80353515625,
0.731953125,
0.65462890625,
0.58052734375,
0.5126171875,
0.4633203125,
0.41298828125,
0.37841796875,
0.355078125,
0.3344921875
],
"cos": [
0.29619003131985666,
0.3314328114688396,
0.3639054714143276,
0.39149928227066993,
0.4152733239531517,
0.4352148090302944,
0.4494645407795906,
0.46180440217256546,
0.47014191970229147,
0.47618671402335166,
0.4810084080696106
]
}
}
}
}
rev2/data/e6_residual_orth.json
Executable
+98
View File
@@ -0,0 +1,98 @@
{
"snr": [
0.0,
2.0,
4.0,
6.0,
8.0,
10.0,
12.0,
14.0,
16.0,
18.0,
20.0
],
"beta_uv_mean": 0.3904166666666667,
"uwca": {
"rho_input": [
0.38956392144163443,
0.38775963683923087,
0.3880219903588295,
0.3881618897616864,
0.38777250061432533,
0.3863464270035427,
0.38830024401346847,
0.38755521948138877,
0.38766041909654947,
0.38740170896053316,
0.38578140864769644
],
"rho_decoded": [
0.305231709529956,
0.31184700431923085,
0.321264610439539,
0.3309843138853709,
0.34082442497213683,
0.35038761819402375,
0.3575822949409485,
0.36593782161672905,
0.37170385092496877,
0.3746264092127481,
0.3768504020571708
],
"rho_residual": [
0.2304025647044181,
0.21344653452436116,
0.19712237288554504,
0.18036628514528272,
0.16850986543421942,
0.15848431913182137,
0.15133254030098522,
0.14582291372120382,
0.14286635869958753,
0.13878688212173684,
0.13878255244344476
]
},
"ofdma": {
"rho_input": [
0.38715864519278204,
0.3887561237315337,
0.387941963672638,
0.3876616556942464,
0.38791437988479943,
0.387366031507651,
0.3880658547083538,
0.3872282171746095,
0.3860448093712329,
0.3875497603913147,
0.3860259728630384
],
"rho_decoded": [
7.473706044644737e-05,
7.072256555450921e-05,
4.665079778836425e-05,
0.00024113242104552518,
-0.0001454370894013361,
0.00019012298099066048,
-0.0001384556134629141,
-0.00015057531054480934,
-0.00047786584111842486,
0.00019809762234217497,
-0.00023452785023740343
],
"rho_residual": [
0.1073327248388281,
0.09175947538033745,
0.07762182657994951,
0.06378789233004983,
0.051325935235557445,
0.04030999146789935,
0.031071071475162172,
0.024056566797662528,
0.017306540097924875,
0.013973580723395568,
0.010691763695795086
]
}
}
rev2/data/e7_meta_family.json
Executable
+1363
View File
File diff suppressed because it is too large Load Diff
rev2/data/e7_v2_meta.json
Executable
+368
View File
@@ -0,0 +1,368 @@
{
"S_grid": [
0,
1,
5,
10,
20
],
"results": {
"ricianK20_phi15_snr10": {
"meta": [
{
"ser": 0.11427083333333334,
"cos": 0.5355387481053671
},
{
"ser": 0.11015625,
"cos": 0.5360154775778453
},
{
"ser": 0.11408854166666667,
"cos": 0.5351665059725443
},
{
"ser": 0.10979166666666666,
"cos": 0.5365686778227489
},
{
"ser": 0.1125,
"cos": 0.5353779737154643
}
],
"lookup": [
{
"ser": 0.15755208333333334,
"cos": 0.5232695064942042
},
{
"ser": 0.152734375,
"cos": 0.523874221642812
},
{
"ser": 0.15614583333333334,
"cos": 0.5235742004712423
},
{
"ser": 0.15640625,
"cos": 0.5232807958126068
},
{
"ser": 0.15302083333333333,
"cos": 0.5241675400733947
}
]
},
"nakagami3_phi5_snr10": {
"meta": [
{
"ser": 0.139296875,
"cos": 0.5291851150989533
},
{
"ser": 0.13609375,
"cos": 0.5295972474416097
},
{
"ser": 0.13533854166666667,
"cos": 0.5308140345414479
},
{
"ser": 0.13786458333333335,
"cos": 0.5300244994958242
},
{
"ser": 0.14177083333333335,
"cos": 0.5283970713615418
}
],
"lookup": [
{
"ser": 0.18973958333333332,
"cos": 0.5160947958628337
},
{
"ser": 0.17627604166666666,
"cos": 0.5183902778228124
},
{
"ser": 0.181484375,
"cos": 0.5170280895630519
},
{
"ser": 0.18481770833333333,
"cos": 0.5159598344564438
},
{
"ser": 0.18231770833333333,
"cos": 0.5171361660957337
}
]
},
"rayleigh_phi20_snr6": {
"meta": [
{
"ser": 0.4521875,
"cos": 0.4479432698090871
},
{
"ser": 0.453828125,
"cos": 0.4469218909740448
},
{
"ser": 0.45458333333333334,
"cos": 0.4469242548942566
},
{
"ser": 0.4532291666666667,
"cos": 0.44761434574921927
},
{
"ser": 0.451640625,
"cos": 0.4476551973819733
}
],
"lookup": [
{
"ser": 0.49497395833333335,
"cos": 0.4364782508214315
},
{
"ser": 0.497421875,
"cos": 0.43555598239103954
},
{
"ser": 0.497109375,
"cos": 0.43593698064486186
},
{
"ser": 0.49963541666666667,
"cos": 0.43608464042345685
},
{
"ser": 0.5034895833333334,
"cos": 0.4354030267397563
}
]
},
"ricianK20_phi15_snr18": {
"meta": [
{
"ser": 0.05213541666666666,
"cos": 0.5592047119140625
},
{
"ser": 0.049895833333333334,
"cos": 0.5594856301943462
},
{
"ser": 0.050494791666666664,
"cos": 0.5598108808199564
},
{
"ser": 0.05002604166666667,
"cos": 0.5593102443218231
},
{
"ser": 0.051484375,
"cos": 0.5590867590904236
}
],
"lookup": [
{
"ser": 0.09625,
"cos": 0.5402481619517009
},
{
"ser": 0.093359375,
"cos": 0.540210163195928
},
{
"ser": 0.09635416666666667,
"cos": 0.5399158314863841
},
{
"ser": 0.09361979166666666,
"cos": 0.5402699712912241
},
{
"ser": 0.09244791666666667,
"cos": 0.5401132162412008
}
]
},
"indist_rayleigh_snr10": {
"meta": [
{
"ser": 0.24442708333333332,
"cos": 0.5030389416217804
},
{
"ser": 0.239375,
"cos": 0.5038288209835688
},
{
"ser": 0.24203125,
"cos": 0.5033370635906855
},
{
"ser": 0.23822916666666666,
"cos": 0.503516077597936
},
{
"ser": 0.23471354166666666,
"cos": 0.5050299618641535
}
],
"lookup": [
{
"ser": 0.29236979166666666,
"cos": 0.4903800235191981
},
{
"ser": 0.28880208333333335,
"cos": 0.4908251702785492
},
{
"ser": 0.28684895833333335,
"cos": 0.49163883725802104
},
{
"ser": 0.2840625,
"cos": 0.4920005202293396
},
{
"ser": 0.2875,
"cos": 0.49090512851874035
}
]
}
},
"eta_traj": [
1.0009888410568237,
0.9988142251968384,
0.9982636570930481,
0.9973306059837341,
0.9959976673126221,
0.9947634339332581,
0.9936885833740234,
0.9931045770645142,
0.9929555654525757,
0.9927845597267151,
0.9922730922698975,
0.9920589923858643,
0.9921906590461731,
0.9921801686286926,
0.9919214844703674,
0.9921574592590332,
0.991858959197998,
0.9914454221725464,
0.9906716346740723,
0.9895113706588745,
0.9881779551506042,
0.9870789051055908,
0.9856075048446655,
0.9844176173210144,
0.9831746220588684,
0.9819408059120178,
0.9820376634597778,
0.9804425239562988,
0.9787063002586365,
0.9777268171310425,
0.9769911766052246,
0.9757769703865051,
0.9740085601806641,
0.9716024398803711,
0.9696326851844788,
0.9672284722328186,
0.9658068418502808,
0.9645152688026428,
0.9632120132446289,
0.962562084197998,
0.961824893951416,
0.9614293575286865,
0.9618523716926575,
0.9624170064926147,
0.9620550870895386,
0.9612102508544922,
0.9611724615097046,
0.9607089161872864,
0.9598875045776367,
0.9586215019226074,
0.9580100178718567,
0.9569817185401917,
0.9565159678459167,
0.9558516144752502,
0.954704999923706,
0.9524244666099548,
0.9503999948501587,
0.9483119249343872,
0.9459860920906067,
0.94413161277771
],
"gnorm_traj": [
0.023208482504073005,
0.02123692131703687,
0.021419118791516166,
0.019711600127132092,
0.019135414989471005,
0.018076975427293435,
0.016569579518674167,
0.01574714791728605,
0.015854544001130864,
0.01491067020364289,
0.01526323321636773,
0.014624104052628336,
0.01524563859595063,
0.014243056657597302,
0.0148277412824214,
0.014620955383358293,
0.014144884905931217,
0.013968142664540066,
0.014892411399669594,
0.013738916719669652,
0.013639220576268603,
0.013447892285315104,
0.013934486859842426,
0.014332657373375508,
0.014262476584197584,
0.013643783498035593,
0.01377261190373069,
0.013472539945253405,
0.013203984465352907,
0.01383900052756837,
0.01331712212948163,
0.013298554708660674,
0.013641285885523019,
0.013616118450480434,
0.013036425940213387,
0.013431248289146479,
0.013511816716475708,
0.014017017260614243,
0.012900150368019506,
0.013370100259288963,
0.013318981910991245,
0.0137673036535571,
0.013798510320460793,
0.013403432306579973,
0.013440239522431556,
0.01281450173493988,
0.012772421311467318,
0.013666647215714567,
0.01275326116724871,
0.013338132260418857,
0.012951403458113723,
0.013345290154289981,
0.013155987746513179,
0.013130926359220358,
0.01290534474999044,
0.012931056238603184,
0.013659869466568731,
0.012398440619775996,
0.012929384856787686,
0.012931776398032845
],
"eta_final": 0.9424571394920349,
"eta_max": 1.0010368824005127,
"gnorm_max": 0.024477812000968838
}
rev2/data/e8_e2e_anticollapse.json
Executable
+107
View File
@@ -0,0 +1,107 @@
{
"snr": [
0.0,
2.0,
4.0,
6.0,
8.0,
10.0,
12.0,
14.0,
16.0,
18.0,
20.0
],
"configs": {
"frozen": {
"ser": [
0.7918229166666667,
0.685703125,
0.5696354166666666,
0.45276041666666667,
0.35044270833333335,
0.270703125,
0.2078125,
0.16442708333333333,
0.14369791666666668,
0.11671875,
0.10502604166666667
],
"cos": [
0.33901638666788736,
0.3792428519328435,
0.41583929598331454,
0.44846010764439903,
0.47460420747598014,
0.49550534566243487,
0.5113285048802694,
0.5235649347305298,
0.530758779446284,
0.5387160217761994,
0.5428356532255808
],
"erank": 63.314430236816406,
"rho_off": 0.998196005821228
},
"naive": {
"ser": [
0.00020833333333333335,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"cos": [
0.9946125821272532,
0.9967783908049266,
0.9977629196643829,
0.9983737409114838,
0.9987331410249074,
0.9989773007233937,
0.9991132164001465,
0.9992019935448965,
0.999260938167572,
0.9992937278747559,
0.9993155153592428
],
"erank": 41.47739028930664,
"rho_off": 0.999997615814209
},
"vicreg": {
"ser": [
0.7002864583333334,
0.5877083333333334,
0.45828125,
0.36255208333333333,
0.28338541666666667,
0.21833333333333332,
0.171875,
0.14651041666666667,
0.12901041666666666,
0.12166666666666667,
0.11083333333333334
],
"cos": [
0.3612262072165807,
0.40026772101720176,
0.4415491064389547,
0.4709076561530431,
0.49452649215857186,
0.5151174678405126,
0.5307369756698609,
0.5408004929622015,
0.5477419094244639,
0.5502727842330932,
0.5561861228942871
],
"erank": 34.763675689697266,
"rho_off": 0.9972559809684753
}
}
}
rev2/data/e8_v2_e2e.json
Executable
+185
View File
@@ -0,0 +1,185 @@
{
"snr": [
0.0,
2.0,
4.0,
6.0,
8.0,
10.0,
12.0,
14.0,
16.0,
18.0,
20.0
],
"configs": {
"frozen": {
"ser": [
0.7918229166666667,
0.685703125,
0.5696354166666666,
0.45276041666666667,
0.35044270833333335,
0.270703125,
0.2078125,
0.16442708333333333,
0.14369791666666668,
0.11671875,
0.10502604166666667
],
"cos": [
0.33901638666788736,
0.3792428519328435,
0.41583929598331454,
0.44846010764439903,
0.47460420747598014,
0.49550534566243487,
0.5113285048802694,
0.5235649347305298,
0.530758779446284,
0.5387160217761994,
0.5428356532255808
],
"retr": [
0.22747395833333334,
0.29614583333333333,
0.36640625,
0.4305729166666667,
0.4890625,
0.5364322916666666,
0.5783854166666667,
0.6016145833333333,
0.6203125,
0.6344270833333333,
0.642265625
],
"erank": 63.314430236816406
},
"e2e_moving": {
"ser": [
0.9998697916666667,
0.99984375,
0.9999479166666667,
0.9999479166666667,
0.9999479166666667,
0.9998958333333333,
0.9999739583333334,
0.9998958333333333,
0.9999479166666667,
0.9998958333333333,
0.9999739583333334
],
"cos": [
-0.0022268955471614997,
0.001013178266584873,
0.0013794303367224833,
0.001468668068603923,
-0.005597147869411856,
-0.0026633564918302,
-0.0047864368790760635,
0.01127757717234393,
-0.0007127511920407415,
0.00015094189438968897,
-0.006568640521727502
],
"retr": [
0.0040885416666666665,
0.0040625,
0.004244791666666667,
0.004479166666666667,
0.004401041666666667,
0.0050260416666666665,
0.004895833333333334,
0.005052083333333333,
0.005078125,
0.005260416666666667,
0.004609375
],
"erank": 41.477378845214844
},
"e2e_anchored": {
"ser": [
0.8076822916666667,
0.7096614583333334,
0.600859375,
0.4913020833333333,
0.39229166666666665,
0.31416666666666665,
0.25463541666666667,
0.20625,
0.17880208333333333,
0.15955729166666666,
0.15265625
],
"cos": [
0.3334804524978002,
0.37222714444001515,
0.40820392191410065,
0.43878923694292704,
0.4647983853022257,
0.48393498480319974,
0.4995024112860362,
0.5123437927166621,
0.519522678454717,
0.5258413887023926,
0.5276070324579875
],
"retr": [
0.23111979166666666,
0.2997916666666667,
0.3709635416666667,
0.43872395833333333,
0.49971354166666665,
0.5374479166666667,
0.573671875,
0.6006510416666667,
0.61859375,
0.63234375,
0.64328125
],
"erank": 59.58533477783203
},
"e2e_vicreg": {
"ser": [
0.9999479166666667,
0.9998958333333333,
0.9998697916666667,
0.99984375,
0.9999479166666667,
0.9998958333333333,
0.999921875,
0.9999739583333334,
0.9999479166666667,
0.999921875,
0.9999739583333334
],
"cos": [
0.003705161992305269,
-0.0008268103026784956,
0.0036043038405478,
0.0009314771206118166,
-0.0039000791516931106,
0.0005898531658264498,
0.004959443456803759,
0.0029063680950397004,
-0.001753986528298507,
-4.444453322018186e-06,
0.002719290911530455
],
"retr": [
0.235546875,
0.30703125,
0.36395833333333333,
0.41716145833333335,
0.4685416666666667,
0.5091145833333334,
0.5313541666666667,
0.548046875,
0.560234375,
0.5616145833333334,
0.5776302083333333
],
"erank": 32.96731185913086
}
}
}
rev2/data/e9_topk_online.json
Executable
+126
View File
@@ -0,0 +1,126 @@
{
"trajectory": {
"frame": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16
],
"online_cos": [
0.17329631745815277,
0.19247668981552124,
0.17097969353199005,
0.17287176847457886,
0.16061195731163025,
0.17628976702690125,
0.16555088758468628,
0.165620356798172,
0.1830531358718872,
0.1789100617170334,
0.1605786234140396,
0.1683427095413208,
0.17294596135616302,
0.16041973233222961,
0.16993699967861176,
0.18056748807430267
],
"oracle_cos": [
0.16824987530708313,
0.18634122610092163,
0.16665780544281006,
0.17287176847457886,
0.16061195731163025,
0.17628976702690125,
0.16555088758468628,
0.165620356798172,
0.1830531358718872,
0.1789100617170334,
0.1605786234140396,
0.1683427095413208,
0.17294596135616302,
0.16041973233222961,
0.16993699967861176,
0.18056748807430267
],
"full_cos": [
0.17329631745815277,
0.19247668981552124,
0.17097969353199005,
0.17735423147678375,
0.16562017798423767,
0.1799776256084442,
0.16680437326431274,
0.1748659312725067,
0.18854433298110962,
0.18770724534988403,
0.16589391231536865,
0.1744101345539093,
0.17331872880458832,
0.1641751229763031,
0.17973534762859344,
0.18085896968841553
],
"beta_err": [
0.006034748163074255,
0.018806079402565956,
0.028256120160222054,
0.03790559619665146,
0.042267411947250366,
0.04524436220526695,
0.04682108759880066,
0.04713748022913933,
0.04687809944152832,
0.04725177213549614,
0.0471353679895401,
0.04652136564254761,
0.04400625079870224,
0.04685147479176521,
0.04681994765996933,
0.04754137992858887
]
},
"timing": {
"U": [
8,
16,
32,
64,
128
],
"full_ms": [
0.31470264948438853,
0.2423646510578692,
0.45809974981239066,
1.5150976993027143,
5.4322567986673675
],
"topk_ms": [
0.2245275492896326,
0.2692323498195037,
0.40805765020195395,
1.6764128507929854,
5.739847800577991
],
"select_ms": [
0.017265090136788785,
0.018207559769507498,
0.018143650086130947,
0.039025599835440516,
0.019912720017600805
]
},
"k": 4,
"warm_frames": 3
}
rev2/e1_fair_baselines.py
Executable
+54
View File
@@ -0,0 +1,54 @@
"""E1 — Degrees-of-freedom fairness (R1.10, R3.7).
Adds full-dimensional receivers on the SAME received signal:
- lmmse_blind : optimal linear receiver with cross-user correlation set to 0
(proves the d/U ceiling is fundamental to correlation-blind
processing, not an artifact of the OFDMA baseline)
- lmmse_genie : optimal linear receiver given the true relevance matrix
(genie-aided upper reference; UWCA should approach it)
- tdma_proj : orthogonal scheme with an arbitrary orthonormal projection
(proves any orthogonal partition is statistically identical
to coordinate masking for isotropic embeddings)
Also trains the UWCA decoder per scenario under the single-signal model and
saves checkpoints for reuse (E6).
"""
import numpy as np
import torch
import lib
from lib import (SCENARIOS, SNR_GRID, UWCA, DEVICE, beta_matrix, block_masks,
eval_scheme, gen_embeddings, save_json, set_seed, train_multitask)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
tasks = [{"snr_db": float(s)} for s in np.arange(0, 21, 4)]
out = {"snr": SNR_GRID.tolist(), "scenarios": {}}
for scen_name in ["HIGH", "LOW", "MIX"]:
scen = SCENARIOS[scen_name]
B = beta_matrix(scen)
def gen(n, scen=scen):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
model = UWCA(d, U, H).to(DEVICE)
train_multitask(model, gen, tasks, epochs=300, tag=f"E1-{scen_name}")
torch.save(model.state_dict(), lib.DATA / f"e1_uwca_{scen_name}.pt")
res = {}
rng_t = torch.Generator().manual_seed(1)
for scheme in ["uwca", "ofdma", "sfdma", "noma", "lmmse_blind",
"lmmse_genie", "tdma_proj"]:
sers, coss = [], []
for snr in SNR_GRID:
t = {"snr_db": float(snr)}
s, c = eval_scheme(scheme, gen, t, n_mc=200, model=model, B=B,
masks=masks, rng_t=rng_t)
sers.append(s); coss.append(c)
res[scheme] = {"ser": sers, "cos": coss}
print(f"[E1-{scen_name}] {scheme}: SER@10dB={sers[5]:.3f} "
f"cos@10dB={coss[5]:.3f}", flush=True)
out["scenarios"][scen_name] = res
save_json("e1_fair_baselines.json", out)
rev2/e2_phase_iui.py
Executable
+129
View File
@@ -0,0 +1,129 @@
"""E2 — Full complex-baseband phase-error model with inter-user leakage (R1.1)
plus CSI amplitude-error robustness (R2.3).
Three evaluation models on HIGH:
scalar : real channel, per-user cos(dphi) attenuation only (old model)
complex-I : full complex superposition; decoder reads the in-phase rail only
complex-IQ: full complex superposition; decoder reads both rails (proposed)
Two trained decoders (phase-augmented training, sigma_phi ~ U[0,20] deg):
m_real (iq=False) and m_iq (iq=True).
Also evaluates a decoder trained at sigma_phi=0 to expose training mismatch,
and a CSI amplitude error sweep for SFDMA (divides by h) vs UWCA (no CSI).
"""
import numpy as np
import torch
import lib
from lib import (SCENARIOS, UWCA, DEVICE, block_masks, channel, eval_scheme,
gen_embeddings, mean_cos, save_json, ser, set_seed,
train_multitask)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
scen = SCENARIOS["HIGH"]
def gen(n):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
snrs = [0.0, 4.0, 8.0, 12.0, 16.0, 20.0]
rng_ph = np.random.default_rng(3)
def aug_tasks():
return [{"snr_db": s, "phase_sigma_deg": float(rng_ph.uniform(0, 20))}
for s in snrs]
class AugTaskList:
"""List-like view that resamples phase residuals each epoch."""
def __init__(self):
self._t = aug_tasks()
self._n = 0
def __len__(self):
return len(self._t)
def __iter__(self):
self._n += 1
self._t = aug_tasks()
return iter(self._t)
m_real = UWCA(d, U, H, iq=False).to(DEVICE)
train_multitask(m_real, gen, AugTaskList(), epochs=300, tag="E2-real-aug")
m_iq = UWCA(d, U, H, iq=True).to(DEVICE)
train_multitask(m_iq, gen, AugTaskList(), epochs=300, tag="E2-iq-aug")
m_zero = UWCA(d, U, H, iq=False).to(DEVICE)
train_multitask(m_zero, gen, [{"snr_db": s} for s in snrs], epochs=300,
tag="E2-zerophase")
torch.save(m_iq.state_dict(), lib.DATA / "e2_uwca_iq.pt")
sig_grid = [0, 5, 10, 15, 20, 30]
out = {"sigma_phi_deg": sig_grid, "snr_eval": [10.0, 20.0], "curves": {}}
@torch.no_grad()
def run(model, sig, snr, mode):
s_acc = c_acc = 0.0
n_mc = 200
for _ in range(n_mc):
E = gen(64)
if mode == "scalar":
# magnitude attenuation only: fold cos(dphi) into the gain, Q rail ignored
ch = channel(E, snr_db=snr, phase_sigma_deg=sig)
# scalar model == complex-I when masks are disjoint; emulate the
# old analytic model by discarding the Q rail entirely
Eh = model(ch["yI"], torch.zeros_like(ch["yQ"]))
elif mode == "cI":
ch = channel(E, snr_db=snr, phase_sigma_deg=sig)
Eh = model(ch["yI"], torch.zeros_like(ch["yQ"])) \
if not model.iq else model(ch["yI"], ch["yQ"])
elif mode == "cIQ":
ch = channel(E, snr_db=snr, phase_sigma_deg=sig)
Eh = model(ch["yI"], ch["yQ"])
s_acc += ser(Eh, E)
c_acc += mean_cos(Eh, E)
return s_acc / n_mc, c_acc / n_mc
for label, model, mode in [("scalar_augtrain", m_real, "scalar"),
("complexI_augtrain", m_real, "cI"),
("complexIQ_iqtrain", m_iq, "cIQ"),
("complexI_zerotrain", m_zero, "cI")]:
cur = {}
for snr in out["snr_eval"]:
cur[str(snr)] = {"ser": [], "cos": []}
for sig in sig_grid:
s, c = run(model, sig, snr, mode)
cur[str(snr)]["ser"].append(s)
cur[str(snr)]["cos"].append(c)
print(f"[E2] {label} snr={snr}: SER={cur[str(snr)]['ser']}", flush=True)
out["curves"][label] = cur
# soft-mask overlap of the trained decoders (quantifies the IUI channel)
with torch.no_grad():
for label, model in [("m_real", m_real), ("m_iq", m_iq)]:
m = model.soft_masks()
ov = (m @ m.T) / (m.norm(dim=1, keepdim=True) * m.norm(dim=1) + 1e-9)
off = ov[~torch.eye(U, dtype=torch.bool, device=ov.device)]
out[f"mask_overlap_{label}"] = {"mean": float(off.mean()),
"max": float(off.max())}
# CSI amplitude error: SFDMA (uses h) vs UWCA (no explicit CSI), sigma_phi=10
h_grid = [0.0, 0.05, 0.1, 0.2]
csi = {"h_err": h_grid, "uwca_ser": [], "sfdma_ser": []}
for he in h_grid:
t = {"snr_db": 10.0, "phase_sigma_deg": 10.0, "h_err_sigma": he}
s_u, _ = eval_scheme("uwca", gen, t, n_mc=200, model=m_iq, masks=masks)
s_f, _ = eval_scheme("sfdma", gen, t, n_mc=200, masks=masks)
csi["uwca_ser"].append(s_u)
csi["sfdma_ser"].append(s_f)
print(f"[E2-CSI] h_err={he}: UWCA {s_u:.3f} SFDMA {s_f:.3f}", flush=True)
out["csi_error"] = csi
save_json("e2_phase_iui.json", out)
rev2/e3_dynamic_users.py
Executable
+99
View File
@@ -0,0 +1,99 @@
"""E3 — Dynamic user arrivals/departures (R1.6, R2.3).
U_max = 8 mask slots, d = 64. Activity-aware meta-training samples a random
active subset each batch; at inference the attention softmax is restricted to
the active set announced by the scheduler (no retraining).
Compared against: (i) a model trained with all 8 users always active
(mismatch), and (ii) oracle models retrained for each fixed active count.
"""
import numpy as np
import torch
import lib
from lib import (SCENARIOS, UWCA, DEVICE, block_masks, channel, gen_embeddings,
mean_cos, save_json, semantic_loss, ser, set_seed)
rng = set_seed(42)
d, Umax, H = 64, 8, 4
masks = block_masks(Umax, d)
scen = SCENARIOS["HIGH8"]
snrs = [0.0, 4.0, 8.0, 12.0, 16.0, 20.0]
act_rng = np.random.default_rng(11)
def gen(n):
return gen_embeddings(n, d, Umax, rng, scen).to(DEVICE)
def sample_active(n, k=None):
"""(n, Umax) bool with k active users (random subset per sample)."""
A = np.zeros((n, Umax), dtype=bool)
for i in range(n):
kk = k if k is not None else int(act_rng.integers(2, Umax + 1))
A[i, act_rng.choice(Umax, size=kk, replace=False)] = True
return torch.from_numpy(A).to(DEVICE)
def train(model, epochs=250, k=None, tag=""):
mask_p = [p for nm, p in model.named_parameters() if "mask_logits" in nm]
other = [p for nm, p in model.named_parameters() if "mask_logits" not in nm]
opt = torch.optim.Adam([{"params": other, "lr": 1e-3},
{"params": mask_p, "lr": 0.1}])
for ep in range(1, epochs + 1):
opt.zero_grad()
loss = 0.0
for s in snrs:
E = gen(64)
act = sample_active(64, k)
Ez = E * act[:, :, None] # inactive users transmit nothing
ch = channel(Ez, snr_db=s)
Eh = model(ch["yI"], ch["yQ"], active=act)
loss = loss + semantic_loss(Eh, E, 0.1, active=act.float())
(loss / len(snrs)).backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
opt.step()
if ep % 50 == 0:
print(f" [E3-{tag}] ep {ep}/{epochs} loss={float(loss)/len(snrs):.4f}",
flush=True)
@torch.no_grad()
def evaluate(model, k, snr, n_mc=200):
s_acc = c_acc = 0.0
for _ in range(n_mc):
E = gen(64)
act = sample_active(64, k)
Ez = E * act[:, :, None]
ch = channel(Ez, snr_db=snr)
Eh = model(ch["yI"], ch["yQ"], active=act)
s_acc += ser(Eh, E, active=act.float())
c_acc += mean_cos(Eh, E, active=act.float())
return s_acc / n_mc, c_acc / n_mc
print("[E3] training activity-aware model", flush=True)
m_act = UWCA(d, Umax, H).to(DEVICE)
train(m_act, tag="act")
torch.save(m_act.state_dict(), lib.DATA / "e3_uwca_act.pt")
print("[E3] training fixed-U8 model", flush=True)
m_fix = UWCA(d, Umax, H).to(DEVICE)
train(m_fix, k=Umax, tag="fix8")
ks = [2, 3, 4, 5, 6, 7, 8]
out = {"k": ks, "snr_eval": [10.0, 20.0], "activity": {}, "fixed8": {},
"oracle": {}}
for snr in out["snr_eval"]:
out["activity"][str(snr)] = [evaluate(m_act, k, snr) for k in ks]
out["fixed8"][str(snr)] = [evaluate(m_fix, k, snr) for k in ks]
print(f"[E3] snr={snr} activity={[f'{a[0]:.3f}' for a in out['activity'][str(snr)]]}",
flush=True)
for k in [2, 4, 6, 8]:
m_o = UWCA(d, Umax, H).to(DEVICE)
train(m_o, k=k, epochs=250, tag=f"oracle{k}")
out["oracle"][str(k)] = {str(snr): evaluate(m_o, k, snr)
for snr in out["snr_eval"]}
print(f"[E3] oracle k={k}: {out['oracle'][str(k)]}", flush=True)
save_json("e3_dynamic_users.json", out)
rev2/e4_v3_async.py
Executable
+94
View File
@@ -0,0 +1,94 @@
"""E4 v3 — Timing offsets with BLOCK-WISE receiver realignment (R1.8).
The BS knows the per-user timing estimates (pilot-based) and realigns each
user's block region individually inside the single received frame:
y_al[b_w + t] = y[b_w + t + delta_w], t = 0..d/U-1
Energy that crossed block boundaries is lost or appears as residual
interference, exactly as in a real system with per-user timing advance error.
"""
import numpy as np
import torch
import torch.nn.functional as F
import lib
from lib import (SCENARIOS, UWCA, DEVICE, block_masks, channel, gen_embeddings,
mean_cos, ofdma_decode, save_json, ser, set_seed)
rng = set_seed(42)
d, U, H = 64, 4, 4
dpu = d // U
masks = block_masks(U, d)
scen = SCENARIOS["HIGH"]
off_rng = np.random.default_rng(5)
def gen(n):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
model = UWCA(d, U, H).to(DEVICE)
model.load_state_dict(torch.load(lib.DATA / "e1_uwca_HIGH.pt",
map_location=DEVICE))
model.eval()
def realign(y, offs_hat):
"""Block-wise realignment: shift each user's block back by its offset."""
n, dd = y.shape
out = torch.zeros_like(y)
for u in range(U):
b0 = u * dpu
for o in offs_hat[:, u].unique():
o = int(o.item())
idx = offs_hat[:, u] == o
src_end = min(b0 + dpu + o, dd)
ln = src_end - (b0 + o)
if ln > 0:
out[idx, b0:b0 + ln] = y[idx, b0 + o:src_end]
return out
@torch.no_grad()
def evaluate(mode, dmax, snr, err_p=0.0, n_mc=200):
s_acc = c_acc = 0.0
for _ in range(n_mc):
E = gen(64)
offs = None
if dmax > 0:
offs = torch.from_numpy(
off_rng.integers(0, dmax + 1, size=(64, U))).to(DEVICE)
ch = channel(E, snr_db=snr, offsets=offs)
y = ch["yI"]
if dmax > 0 and mode.endswith("cor"):
offs_hat = offs.clone()
if err_p > 0:
flip = torch.from_numpy(
off_rng.random((64, U)) < err_p).to(DEVICE)
pm = torch.from_numpy(
off_rng.choice([-1, 1], size=(64, U))).to(DEVICE)
offs_hat = (offs_hat + flip.long() * pm).clamp(min=0)
y = realign(y, offs_hat)
if mode.startswith("uwca"):
Eh = model(y, ch["yQ"])
else:
Eh = ofdma_decode(y, masks)
s_acc += ser(Eh, E)
c_acc += mean_cos(Eh, E)
return s_acc / n_mc, c_acc / n_mc
dgrid = [0, 1, 2, 4, 8]
out = {"dmax": dgrid, "snr_eval": [10.0, 20.0], "curves": {}}
for label, mode, ep in [("uwca_uncorrected", "uwca_unc", 0.0),
("ofdma_uncorrected", "ofdma_unc", 0.0),
("uwca_corrected", "uwca_cor", 0.0),
("ofdma_corrected", "ofdma_cor", 0.0),
("uwca_corrected_err20", "uwca_cor", 0.2)]:
cur = {}
for snr in out["snr_eval"]:
cur[str(snr)] = [evaluate(mode, dm, snr, ep) for dm in dgrid]
out["curves"][label] = cur
print(f"[E4v3] {label} 10dB SER: "
f"{[round(a[0],3) for a in cur['10.0']]}", flush=True)
save_json("e4_v3_async.json", out)
rev2/e5_nonlinear.py
Executable
+55
View File
@@ -0,0 +1,55 @@
"""E5 — Nonlinear inter-user semantic structure (R1.7, R2.5, R3.2).
Embeddings are produced by fixed random per-user nonlinear view networks
e_u = normalize(g_u([kappa*s ; p_u])), so the inter-user dependence is
nonlinear and NOT captured by any scalar coefficient or linear covariance.
NONLIN-HIGH: shared s (kappa=1); NONLIN-LOW: independent s per user.
Shows the trained UWCA decoder still exploits the shared structure while the
scalar-parameterized genie LMMSE (mis-specified here) cannot fully.
"""
import numpy as np
import torch
import lib
from lib import (UWCA, DEVICE, ViewNets, block_masks, eval_scheme, save_json,
set_seed, train_multitask, SNR_GRID)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
vnets = ViewNets(d, U).to(DEVICE)
tasks = [{"snr_db": float(s)} for s in np.arange(0, 21, 4)]
out = {"snr": SNR_GRID.tolist(), "cases": {}}
for case, (kappa, shared) in {"NONLIN-HIGH": (1.0, True),
"NONLIN-LOW": (1.0, False)}.items():
def gen(n, kappa=kappa, shared=shared):
return vnets.gen(n, d, U, rng, kappa, shared)
# empirical mean pairwise cosine (the "effective" relevance)
E = gen(2048)
C = torch.einsum("nud,nvd->uv", E, E) / 2048
off = C[~torch.eye(U, dtype=torch.bool, device=C.device)]
beta_emp = float(off.mean())
print(f"[E5-{case}] empirical mean pairwise cosine = {beta_emp:.3f}",
flush=True)
# mis-specified scalar-model LMMSE uses beta_emp for every pair
B = np.full((U, U), beta_emp)
np.fill_diagonal(B, 1.0)
model = UWCA(d, U, H).to(DEVICE)
train_multitask(model, gen, tasks, epochs=300, tag=f"E5-{case}")
res = {"beta_emp": beta_emp}
for scheme in ["uwca", "ofdma", "noma", "lmmse_genie"]:
sers, coss = [], []
for snr in SNR_GRID:
s, c = eval_scheme(scheme, gen, {"snr_db": float(snr)}, n_mc=200,
model=model, B=B, masks=masks)
sers.append(s); coss.append(c)
res[scheme] = {"ser": sers, "cos": coss}
print(f"[E5-{case}] {scheme}: SER@10dB={sers[5]:.3f}", flush=True)
out["cases"][case] = res
save_json("e5_nonlinear.json", out)
rev2/e6_residual_orth.py
Executable
+66
View File
@@ -0,0 +1,66 @@
"""E6 — Residual (error) orthogonality vs. content preservation (R1.4, R3.3, R2.2).
Resolves the claimed contradiction: the decoded embeddings PRESERVE the shared
scene correlation (rho(e_hat_u, e_hat_v) tracks beta_uv), while the decoding
RESIDUALS r_u = e_hat_u - e_u decorrelate (rho(r_u, r_v) -> 0), which is the
interference-suppression property. Measured per-sample across dimensions on
the E1 HIGH-trained decoder, vs SNR, together with the scene-component cosine.
"""
import numpy as np
import torch
import lib
from lib import (SCENARIOS, SNR_GRID, UWCA, DEVICE, beta_matrix, block_masks,
channel, gen_embeddings, ofdma_decode, sample_corr, save_json,
set_seed)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
scen = SCENARIOS["HIGH"]
B = beta_matrix(scen)
model = UWCA(d, U, H).to(DEVICE)
model.load_state_dict(torch.load(lib.DATA / "e1_uwca_HIGH.pt",
map_location=DEVICE))
model.eval()
pairs = [(u, v) for u in range(U) for v in range(u + 1, U)]
out = {"snr": SNR_GRID.tolist(), "beta_uv_mean": float(np.mean(
[B[u, v] for u, v in pairs])), "uwca": {}, "ofdma": {}}
@torch.no_grad()
def measure(decode_fn):
rho_in, rho_out, rho_res = [], [], []
for snr in SNR_GRID:
a_in = a_out = a_res = 0.0
n_mc = 100
for _ in range(n_mc):
E = gen_embeddings(64, d, U, rng, scen).to(DEVICE)
ch = channel(E, snr_db=float(snr))
Eh = decode_fn(ch)
R = Eh - E
pi = po = pr = 0.0
for u, v in pairs:
pi += sample_corr(E[:, u], E[:, v])
po += sample_corr(Eh[:, u], Eh[:, v])
pr += sample_corr(R[:, u], R[:, v])
a_in += pi / len(pairs)
a_out += po / len(pairs)
a_res += pr / len(pairs)
rho_in.append(a_in / n_mc)
rho_out.append(a_out / n_mc)
rho_res.append(a_res / n_mc)
return rho_in, rho_out, rho_res
ri, ro, rr = measure(lambda ch: model(ch["yI"], ch["yQ"]))
out["uwca"] = {"rho_input": ri, "rho_decoded": ro, "rho_residual": rr}
print(f"[E6] UWCA rho_in={ri[5]:.3f} rho_dec={ro[5]:.3f} rho_res={rr[5]:.3f} @10dB",
flush=True)
ri, ro, rr = measure(lambda ch: ofdma_decode(ch["yI"], masks))
out["ofdma"] = {"rho_input": ri, "rho_decoded": ro, "rho_residual": rr}
save_json("e6_residual_orth.json", out)
rev2/e7_v2_meta.py
Executable
+93
View File
@@ -0,0 +1,93 @@
"""E7 v2 — Meta-training over the multi-dimensional task family, OOD transfer,
adaptation sweep, and eta/gradient logging.
meta : the paper's first-order meta-training aggregated over the FULL
36-task family (SNR x {Rayleigh, Rician K=5,10 dB} x phase {0,10 deg})
lookup : per-SNR specialists trained on Rayleigh / no phase error, indexed by
nearest SNR (the 1-D lookup table)
Test on held-out task combinations (incl. unseen Nakagami fading), zero-shot
and with S in {1,5,10,20} inner adaptation steps from each initialization.
"""
import numpy as np
import torch
import lib
from lib import (SCENARIOS, UWCA, DEVICE, adapt, block_masks, eval_scheme,
gen_embeddings, save_json, set_seed, train_multitask)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
scen = SCENARIOS["HIGH"]
def gen(n):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
snrs = [0.0, 4.0, 8.0, 12.0, 16.0, 20.0]
fads = [{"fading": "rayleigh"},
{"fading": "rician", "rician_K_dB": 5.0},
{"fading": "rician", "rician_K_dB": 10.0}]
phis = [0.0, 10.0]
family = [{"snr_db": s, "phase_sigma_deg": p, **f}
for s in snrs for f in fads for p in phis]
eta_log = []
m_meta = UWCA(d, U, H).to(DEVICE)
train_multitask(m_meta, gen, family, epochs=300, tag="E7v2-meta",
log_state=eta_log)
torch.save(m_meta.state_dict(), lib.DATA / "e7v2_meta.pt")
specialists = {}
for s in snrs:
m = UWCA(d, U, H).to(DEVICE)
train_multitask(m, gen, [{"snr_db": s}], epochs=150,
tag=f"E7v2-spec{int(s)}")
specialists[s] = m
def lookup(snr):
return specialists[min(snrs, key=lambda x: abs(x - snr))]
test_tasks = {
"ricianK20_phi15_snr10": {"snr_db": 10.0, "fading": "rician",
"rician_K_dB": 20.0, "phase_sigma_deg": 15.0},
"nakagami3_phi5_snr10": {"snr_db": 10.0, "fading": "nakagami",
"nakagami_m": 3.0, "phase_sigma_deg": 5.0},
"rayleigh_phi20_snr6": {"snr_db": 6.0, "fading": "rayleigh",
"phase_sigma_deg": 20.0},
"ricianK20_phi15_snr18": {"snr_db": 18.0, "fading": "rician",
"rician_K_dB": 20.0, "phase_sigma_deg": 15.0},
"indist_rayleigh_snr10": {"snr_db": 10.0, "fading": "rayleigh",
"phase_sigma_deg": 0.0},
}
S_grid = [0, 1, 5, 10, 20]
out = {"S_grid": S_grid, "results": {}}
for name, t in test_tasks.items():
row = {}
for label, base in [("meta", m_meta), ("lookup", lookup(t["snr_db"]))]:
sers = []
for S in S_grid:
mdl = base if S == 0 else adapt(base, gen, t, steps=S,
inner_lr=0.02)
s, c = eval_scheme("uwca", gen, t, n_mc=150, model=mdl,
masks=masks)
sers.append({"ser": s, "cos": c})
row[label] = sers
out["results"][name] = row
print(f"[E7v2] {name}: meta={[round(x['ser'],3) for x in row['meta']]} "
f"lookup={[round(x['ser'],3) for x in row['lookup']]}", flush=True)
etas = [e["eta"] for e in eta_log]
gns = [e["gnorm"] for e in eta_log]
out["eta_traj"] = etas[::5]
out["gnorm_traj"] = gns[::5]
out["eta_final"], out["eta_max"] = etas[-1], max(etas)
out["gnorm_max"] = max(gns)
print(f"[E7v2] eta final={etas[-1]:.3f} max={max(etas):.3f} "
f"gnorm max={max(gns):.3f}", flush=True)
save_json("e7_v2_meta.json", out)
rev2/e8_v2_e2e.py
Executable
+125
View File
@@ -0,0 +1,125 @@
"""E8 v2 — End-to-end joint encoder-decoder training (R1.5), source-anchored.
All fidelity metrics are measured against the SOURCE embedding normalize(x),
never against the trainable encoder output (a moving target that makes
collapse look like success).
Configs (HIGH):
frozen : identity encoder, decoder trained (paper reference)
e2e_moving : trainable encoder, loss vs f_phi(x) (collapse demo)
e2e_anchored : trainable encoder, loss vs normalize(x) (fixed anchor)
e2e_vicreg : trainable encoder, loss vs f_phi(x) + VICReg anti-collapse
Metrics: SER/cos vs normalize(x); batch nearest-neighbor retrieval accuracy;
encoder-output effective rank and off-diagonal correlation.
"""
import numpy as np
import torch
import torch.nn.functional as F
import lib
from lib import (SCENARIOS, SNR_GRID, UWCA, DEVICE, Encoder, block_masks,
channel, gen_embeddings, save_json, semantic_loss, set_seed)
rng = set_seed(42)
d, U, H = 64, 4, 4
masks = block_masks(U, d)
scen = SCENARIOS["HIGH"]
snrs = [0.0, 4.0, 8.0, 12.0, 16.0, 20.0]
def gen(n):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
def vicreg_reg(Z):
Zc = Z - Z.mean(0, keepdim=True)
std = (Zc.var(0) + 1e-4).sqrt()
v = F.relu(1.0 / d ** 0.5 - std).mean()
C = (Zc.T @ Zc) / (Z.shape[0] - 1)
off = C - torch.diag(torch.diag(C))
c = (off ** 2).sum() / d
return 25.0 * v + 100.0 * c
def train(mode, epochs=300):
model = UWCA(d, U, H).to(DEVICE)
enc = Encoder(d).to(DEVICE) if mode != "frozen" else None
mask_p = [p for nm, p in model.named_parameters() if "mask_logits" in nm]
other = [p for nm, p in model.named_parameters() if "mask_logits" not in nm]
groups = [{"params": other, "lr": 1e-3}, {"params": mask_p, "lr": 0.1}]
if enc is not None:
groups.append({"params": enc.parameters(), "lr": 1e-3})
opt = torch.optim.Adam(groups)
for ep in range(1, epochs + 1):
opt.zero_grad()
loss = 0.0
for s in snrs:
X = gen(64)
n = X.shape[0]
E = enc(X.reshape(-1, d)).reshape(n, U, d) if enc is not None else X
target = E if mode in ("frozen", "e2e_moving", "e2e_vicreg") else X
ch = channel(E, snr_db=s)
Eh = model(ch["yI"], ch["yQ"])
L = semantic_loss(Eh, target.detach()
if mode == "e2e_moving_detach" else target, 0.1)
if mode == "e2e_vicreg":
L = L + vicreg_reg(E.reshape(-1, d))
loss = loss + L
(loss / len(snrs)).backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
opt.step()
if ep % 75 == 0:
print(f" [E8v2-{mode}] ep {ep}/{epochs} "
f"loss={float(loss)/len(snrs):.4f}", flush=True)
return model, enc
@torch.no_grad()
def collapse_metrics(enc):
X = gen(1024).reshape(-1, d)
Z = enc(X) if enc is not None else F.normalize(X, dim=-1)
Zc = Z - Z.mean(0, keepdim=True)
C = (Zc.T @ Zc) / (Z.shape[0] - 1)
ev = torch.linalg.eigvalsh(C).clamp(min=1e-12)
p = ev / ev.sum()
return float(torch.exp(-(p * p.log()).sum()))
@torch.no_grad()
def curves(model, enc):
ss, cc, rr = [], [], []
for snr in SNR_GRID:
a = b = r = 0.0
n_mc = 150
for _ in range(n_mc):
X = gen(64)
n = X.shape[0]
E = enc(X.reshape(-1, d)).reshape(n, U, d) if enc is not None else X
ch = channel(E, snr_db=float(snr))
Eh = model(ch["yI"], ch["yQ"])
# all metrics vs the SOURCE
cos = (Eh * X).sum(-1)
a += float((cos < 0.45).float().mean())
b += float(cos.mean())
# batch retrieval: nearest ENCODED gallery entry (collapse makes
# the gallery indistinguishable and drives accuracy to chance)
q = Eh.reshape(-1, d)
g = E.reshape(-1, d)
sim = q @ g.T
r += float((sim.argmax(1) == torch.arange(q.shape[0],
device=q.device))
.float().mean())
ss.append(a / n_mc); cc.append(b / n_mc); rr.append(r / n_mc)
return ss, cc, rr
out = {"snr": SNR_GRID.tolist(), "configs": {}}
for mode in ["frozen", "e2e_moving", "e2e_anchored", "e2e_vicreg"]:
model, enc = train(mode)
erank = collapse_metrics(enc)
ss, cc, rr = curves(model, enc)
out["configs"][mode] = {"ser": ss, "cos": cc, "retr": rr, "erank": erank}
print(f"[E8v2] {mode}: erank={erank:.1f} SER@10={ss[5]:.3f} "
f"cos@10={cc[5]:.3f} retr@10={rr[5]:.3f}", flush=True)
save_json("e8_v2_e2e.json", out)
rev2/e9_topk_online.py
Executable
+144
View File
@@ -0,0 +1,144 @@
"""E9 — Online relevance acquisition for sparse top-k attention (R1.2, R3.6)
and measured selection/sorting overhead (R2.4).
Protocol (U=32, 8 clusters of 4, k=4):
frames 1..3 : full attention; the BS estimates beta_hat from the decoded
embeddings by an EWMA of pairwise cosines (no oracle knowledge)
frames >=4 : top-k attention using beta_hat (self + k-1 best peers)
Reports the per-frame fidelity trajectory against the oracle top-k (true
clusters) and full attention, plus wall-clock timing of the full pipeline
including estimation and argpartition selection for U in {8..128}.
"""
import time
import numpy as np
import torch
import lib
from lib import (UWCA, DEVICE, block_masks, channel, gen_embeddings,
mean_cos, save_json, semantic_loss, ser, set_seed)
rng = set_seed(42)
d, H, k = 64, 4, 4
U = 32
G = U // k # 8 clusters of 4
scen = {"beta_u": [0.65] * U, "scenes": [i // k for i in range(U)]}
masks = block_masks(U, d)
snrs = [0.0, 10.0, 20.0]
def gen(n):
return gen_embeddings(n, d, U, rng, scen).to(DEVICE)
def cluster_mask():
m = torch.zeros(U, U, dtype=torch.bool, device=DEVICE)
for u in range(U):
c = u // k
m[u, c * k:(c + 1) * k] = True
return m
def topk_from_beta(bhat):
m = torch.zeros(U, U, dtype=torch.bool, device=DEVICE)
b = bhat.clone()
b.fill_diagonal_(2.0) # always keep self
idx = torch.topk(b, k, dim=1).indices
m.scatter_(1, idx, True)
return m
print("[E9] training U=32 model (full attention)", flush=True)
model = UWCA(d, U, H).to(DEVICE)
mask_p = [p for nm, p in model.named_parameters() if "mask_logits" in nm]
other = [p for nm, p in model.named_parameters() if "mask_logits" not in nm]
opt = torch.optim.Adam([{"params": other, "lr": 1e-3},
{"params": mask_p, "lr": 0.1}])
for ep in range(1, 181):
opt.zero_grad()
loss = 0.0
for s in snrs:
E = gen(64)
ch = channel(E, snr_db=s)
Eh = model(ch["yI"], ch["yQ"])
loss = loss + semantic_loss(Eh, E, 0.1)
(loss / len(snrs)).backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
opt.step()
if ep % 45 == 0:
print(f" [E9] ep {ep}/180 loss={float(loss)/len(snrs):.4f}", flush=True)
# ---- online protocol trajectory at 10 dB
T, warm, gamma_ewma = 16, 3, 0.5
oracle = cluster_mask()
traj = {"frame": list(range(1, T + 1)), "online_cos": [], "oracle_cos": [],
"full_cos": [], "beta_err": []}
bhat = torch.zeros(U, U, device=DEVICE)
model.eval()
Btrue = torch.zeros(U, U, device=DEVICE)
for u in range(U):
for v in range(U):
if u != v and scen["scenes"][u] == scen["scenes"][v]:
Btrue[u, v] = scen["beta_u"][u] * scen["beta_u"][v]
with torch.no_grad():
for t in range(1, T + 1):
E = gen(256)
ch = channel(E, snr_db=10.0)
tk = None if t <= warm else topk_from_beta(bhat)
Eh = model(ch["yI"], ch["yQ"], topk_mask=tk)
# BS-side estimate from decoded embeddings only
Cb = torch.einsum("nud,nvd->uv", Eh, Eh) / Eh.shape[0]
Cb.fill_diagonal_(0.0)
bhat = gamma_ewma * bhat + (1 - gamma_ewma) * Cb
Ehf = model(ch["yI"], ch["yQ"])
Eho = model(ch["yI"], ch["yQ"], topk_mask=oracle)
traj["online_cos"].append(mean_cos(Eh, E))
traj["full_cos"].append(mean_cos(Ehf, E))
traj["oracle_cos"].append(mean_cos(Eho, E))
traj["beta_err"].append(float((bhat - Btrue).abs().mean()))
print(f"[E9] frame {t}: online={traj['online_cos'][-1]:.4f} "
f"oracle={traj['oracle_cos'][-1]:.4f} "
f"full={traj['full_cos'][-1]:.4f}", flush=True)
# ---- wall-clock overhead incl. estimation + argpartition selection
timing = {"U": [8, 16, 32, 64, 128], "full_ms": [], "topk_ms": [],
"select_ms": []}
for Ut in timing["U"]:
dt = max(d, 2 * Ut) # keep at least 2 dims per user slot
mt = UWCA(dt, Ut, H).to(DEVICE).eval()
ch = {"yI": torch.randn(256, dt, device=DEVICE),
"yQ": torch.randn(256, dt, device=DEVICE)}
bh = torch.rand(Ut, Ut, device=DEVICE)
with torch.no_grad():
for _ in range(3):
mt(ch["yI"], ch["yQ"]) # warm-up
torch.cuda.synchronize()
t0 = time.perf_counter()
for _ in range(20):
mt(ch["yI"], ch["yQ"])
torch.cuda.synchronize()
t_full = (time.perf_counter() - t0) / 20 * 1e3
t0 = time.perf_counter()
for _ in range(20):
b = bh.clone(); b.fill_diagonal_(2.0)
idx = torch.topk(b, k, dim=1).indices
tkm = torch.zeros(Ut, Ut, dtype=torch.bool, device=DEVICE)
tkm.scatter_(1, idx, True)
mt(ch["yI"], ch["yQ"], topk_mask=tkm)
torch.cuda.synchronize()
t_topk = (time.perf_counter() - t0) / 20 * 1e3
t0 = time.perf_counter()
for _ in range(100):
b = bh.clone(); b.fill_diagonal_(2.0)
idx = torch.topk(b, k, dim=1).indices
torch.cuda.synchronize()
t_sel = (time.perf_counter() - t0) / 100 * 1e3
timing["full_ms"].append(t_full)
timing["topk_ms"].append(t_topk)
timing["select_ms"].append(t_sel)
print(f"[E9] U={Ut}: full={t_full:.2f}ms topk={t_topk:.2f}ms "
f"select={t_sel:.3f}ms", flush=True)
save_json("e9_topk_online.json", {"trajectory": traj, "timing": timing,
"k": k, "warm_frames": warm})
rev2/lib.py
Executable
+490
View File
@@ -0,0 +1,490 @@
"""
Shared library for TWC revision-2 experiments (new submission).
Single-signal uplink model matching the manuscript:
y = sum_v g_v (e_v ⊙ m_v) + n, g_v = |h_v| e^{jΔφ_v}
All experiments import from here. Seed fixed = 42.
"""
import copy
import json
import math
import time
from pathlib import Path
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
DATA = Path(__file__).resolve().parent / "data"
DATA.mkdir(exist_ok=True)
SCENARIOS = {
"HIGH": {"beta_u": [0.65, 0.65, 0.60, 0.60], "scenes": [0, 0, 0, 0]},
"LOW": {"beta_u": [0.65, 0.05, 0.05, 0.05], "scenes": [0, 1, 2, 3]},
"MIX": {"beta_u": [0.65, 0.65, 0.05, 0.05], "scenes": [0, 0, 1, 2]},
# 8-slot high-correlation scenario for dynamic-user experiment
"HIGH8": {"beta_u": [0.60] * 8, "scenes": [0] * 8},
}
SNR_GRID = np.arange(0.0, 20.0 + 1e-6, 2.0)
def beta_matrix(scen):
"""True relevance matrix beta_{u,v} = beta_u beta_v [same scene], else 0."""
b = np.asarray(scen["beta_u"], dtype=np.float64)
sc = np.asarray(scen["scenes"])
U = len(b)
B = np.zeros((U, U))
for u in range(U):
for v in range(U):
B[u, v] = 1.0 if u == v else (b[u] * b[v] if sc[u] == sc[v] else 0.0)
return B
def gen_embeddings(n, d, U, rng, scen):
"""Unit-norm ground-truth embeddings (n, U, d): e_u = sqrt(1-b^2) p + b s."""
blend, scenes = scen["beta_u"], scen["scenes"]
svecs = {}
for sc in sorted(set(scenes)):
v = rng.standard_normal(d)
svecs[sc] = v / (np.linalg.norm(v) + 1e-8)
embs = []
for u in range(U):
b = blend[u]
p = rng.standard_normal((n, d))
p /= np.linalg.norm(p, axis=-1, keepdims=True) + 1e-8
e = np.sqrt(max(1 - b * b, 0.0)) * p + b * svecs[scenes[u]][None, :]
e /= np.linalg.norm(e, axis=-1, keepdims=True) + 1e-8
embs.append(e)
return torch.from_numpy(np.stack(embs, 1)).float()
class ViewNets(nn.Module):
"""Fixed random per-user nonlinear view functions g_u([kappa*s; p_u])."""
def __init__(self, d, U, seed=7):
super().__init__()
g = torch.Generator().manual_seed(seed)
self.nets = nn.ModuleList()
for _ in range(U):
l1 = nn.Linear(2 * d, 2 * d)
l2 = nn.Linear(2 * d, d)
for l in (l1, l2):
nn.init.normal_(l.weight, std=(2.0 / l.in_features) ** 0.5, generator=g)
nn.init.zeros_(l.bias)
self.nets.append(nn.Sequential(l1, nn.Tanh(), l2))
for p in self.parameters():
p.requires_grad_(False)
@torch.no_grad()
def gen(self, n, d, U, rng, kappa, shared_scene=True):
if shared_scene:
s = rng.standard_normal((n, d)) / math.sqrt(d)
s = np.repeat(s[:, None, :], U, axis=1)
else:
s = rng.standard_normal((n, U, d)) / math.sqrt(d)
p = rng.standard_normal((n, U, d)) / math.sqrt(d)
s = torch.from_numpy(s).float().to(DEVICE)
p = torch.from_numpy(p).float().to(DEVICE)
outs = []
for u in range(U):
x = torch.cat([kappa * s[:, u], p[:, u]], -1)
outs.append(F.normalize(self.nets[u](x), dim=-1))
return torch.stack(outs, 1) # (n, U, d)
def block_masks(U, d, device=DEVICE):
dpu = d // U
m = torch.zeros(U, d, device=device)
for u in range(U):
m[u, u * dpu:(u + 1) * dpu] = 1.0
return m
def channel(E, snr_db, *, phase_sigma_deg=0.0, fading="rayleigh", rician_K_dB=None,
nakagami_m=None, offsets=None, h_err_sigma=0.0, masks=None, use_masks=True):
"""Single-signal uplink. Returns dict with yI, yQ, h (true magnitude), h_hat.
E : (n, U, d) ground-truth embeddings on DEVICE.
offsets : (n, U) integer per-user timing offsets (symbols), or None.
Noise convention: per-rail noise std = sqrt(mean|y_tx|^2 / snr_lin); with
phase_sigma = 0 the model reduces exactly to the real-valued model.
"""
n, U, d = E.shape
if masks is None:
masks = block_masks(U, d, E.device)
X = E * masks[None] if use_masks else E.clone()
if offsets is not None:
Xs = torch.zeros_like(X)
offs = offsets
for u in range(U):
for o in offs[:, u].unique():
o = int(o.item())
idx = offs[:, u] == o
if o == 0:
Xs[idx, u] = X[idx, u]
else:
Xs[idx, u, o:] = X[idx, u, :d - o]
X = Xs
if fading == "rayleigh":
hI = torch.randn(n, U, device=E.device) * (0.5 ** 0.5)
hQ = torch.randn(n, U, device=E.device) * (0.5 ** 0.5)
hmag = (hI ** 2 + hQ ** 2).sqrt()
elif fading == "rician":
K = 10 ** (rician_K_dB / 10.0)
mu = math.sqrt(K / (K + 1))
sig = math.sqrt(1.0 / (2 * (K + 1)))
hI = mu + torch.randn(n, U, device=E.device) * sig
hQ = torch.randn(n, U, device=E.device) * sig
hmag = (hI ** 2 + hQ ** 2).sqrt()
elif fading == "nakagami":
m = nakagami_m
gam = torch.distributions.Gamma(m, m).sample((n, U)).to(E.device)
hmag = gam.sqrt()
else:
raise ValueError(fading)
dphi = torch.randn(n, U, device=E.device) * math.radians(phase_sigma_deg)
gI = hmag * torch.cos(dphi)
gQ = hmag * torch.sin(dphi)
yI = (gI[:, :, None] * X).sum(1)
yQ = (gQ[:, :, None] * X).sum(1)
P = (yI ** 2 + yQ ** 2).mean()
nstd = (P / (10 ** (snr_db / 10.0))).sqrt()
yI = yI + torch.randn_like(yI) * nstd
yQ = yQ + torch.randn_like(yQ) * nstd
h_hat = hmag * (1 + torch.randn_like(hmag) * h_err_sigma) if h_err_sigma > 0 else hmag
return {"yI": yI, "yQ": yQ, "h": hmag, "h_hat": h_hat, "nvar": float(nstd ** 2)}
# ---------------------------------------------------------------- decoders --
class UWCA(nn.Module):
"""User-wise cross-attention decoder on the single superimposed signal.
iq=True : keys/values read the stacked [I; Q] rails (2d input).
forward(yI, yQ, active) with active (n, U) bool or None.
"""
def __init__(self, d, U, H=4, iq=False):
super().__init__()
assert d % H == 0
self.d, self.U, self.H, self.dk = d, U, H, d // H
self.iq = iq
din = 2 * d if iq else d
self.q_vectors = nn.Parameter(torch.randn(U, d) * d ** -0.5)
self.eta = nn.Parameter(torch.ones(1))
self.W_K = nn.Linear(din, d, bias=False)
self.W_V = nn.Linear(din, d, bias=False)
self.W_O = nn.Linear(d, d, bias=False)
self.norm = nn.LayerNorm(d)
init_logits = torch.full((U, d), -3.0)
dpu = d // U
for u in range(U):
init_logits[u, u * dpu:(u + 1) * dpu] = 3.0
self.mask_logits = nn.Parameter(init_logits)
def soft_masks(self):
return torch.sigmoid(self.mask_logits)
def forward(self, yI, yQ=None, active=None, topk_mask=None, return_alpha=False):
# yI: (n, d) shared signal, or (n, U, d) per-candidate aligned copies
U, H, dk = self.U, self.H, self.dk
m = self.soft_masks() # (U, d)
if yI.dim() == 2:
n, d = yI.shape
yIc = yI[:, None, :].expand(-1, U, -1)
else:
n, _, d = yI.shape
yIc = yI
R = yIc * m[None] # (n, U, d)
if self.iq:
yQc = yQ[:, None, :].expand(-1, U, -1) if yQ.dim() == 2 else yQ
RQ = yQc * m[None]
Rin = torch.cat([R, RQ], -1) # (n, U, 2d)
else:
Rin = R
K = self.W_K(Rin).view(n, U, H, dk) # (n, Uk, H, dk)
V = self.W_V(Rin).view(n, U, H, dk)
Q = self.q_vectors.view(U, H, dk) # (Uq, H, dk)
scores = torch.einsum("qhk,nihk->nqhi", Q, K) * self.eta / dk ** 0.5
if active is not None: # (n, U) bool
scores = scores.masked_fill(~active[:, None, None, :], -1e9)
if topk_mask is not None: # (U, U) bool keep
scores = scores.masked_fill(~topk_mask[None, :, None, :], -1e9)
alpha = F.softmax(scores, dim=-1) # (n, Uq, H, Uk)
ctx = torch.einsum("nqhi,nihk->nqhk", alpha, V).reshape(n, U, d)
own = yIc * m[None]
out = F.normalize(self.norm(self.W_O(ctx) + own), dim=-1)
if return_alpha:
return out, alpha.mean(dim=(0, 2))
return out
class Encoder(nn.Module):
"""Trainable semantic encoder for the end-to-end experiment."""
def __init__(self, d):
super().__init__()
self.net = nn.Sequential(nn.Linear(d, 2 * d), nn.LayerNorm(2 * d),
nn.GELU(), nn.Linear(2 * d, d))
def forward(self, x):
return F.normalize(self.net(x), dim=-1)
def ofdma_decode(yI, masks):
return F.normalize(yI[:, None, :] * masks[None], dim=-1)
def tdma_proj_decode(E, snr_db, rng_t):
"""Orthogonal scheme with an arbitrary (random orthonormal) d/U-dim
projection per user instead of coordinate masks: z_u = h_u P_u e_u + n."""
n, U, d = E.shape
dpu = d // U
Q, _ = torch.linalg.qr(torch.randn(d, d, generator=rng_t).to(E.device))
outs = []
hmag = (torch.randn(n, U, device=E.device) ** 2 +
torch.randn(n, U, device=E.device) ** 2).sqrt() * 0.5 ** 0.5
snr_lin = 10 ** (snr_db / 10.0)
for u in range(U):
P = Q[u * dpu:(u + 1) * dpu] # (dpu, d)
z = hmag[:, u:u + 1] * (E[:, u] @ P.T) # (n, dpu)
nstd = (z.pow(2).mean() / snr_lin).sqrt()
z = z + torch.randn_like(z) * nstd
outs.append(F.normalize(z @ P, dim=-1))
return torch.stack(outs, 1)
def lmmse_decode(yI, h, nvar, B, masks, genie=True):
"""Closed-form linear MMSE on the block model. C_vv = I/d, C_uv = B_uv I/d.
Block-diagonal C_y => per-block Wiener weights w_uv = h_v B_uv/d / (h_v^2/d + nvar).
genie=False zeroes the cross terms (correlation-blind)."""
n, d = yI.shape
U = masks.shape[0]
Bm = torch.as_tensor(B, dtype=torch.float32, device=yI.device)
if not genie:
Bm = torch.eye(U, device=yI.device)
yb = yI[:, None, :] * masks[None] # (n, Uv, d) block pieces
w = (h[:, None, :] * Bm[None] / d) / (h[:, None, :] ** 2 / d + nvar) # (n,Uu,Uv)
est = torch.einsum("nuv,nvd->nud", w, yb)
return F.normalize(est, dim=-1)
def noma_sic_decode(E, snr_db):
"""Full-band power-domain NOMA with SIC (no masks)."""
n, U, d = E.shape
pa = torch.tensor([0.40, 0.30, 0.20, 0.10], device=E.device)[:U]
pa = pa / pa.sum()
h = (torch.randn(n, U, 1, device=E.device) ** 2 +
torch.randn(n, U, 1, device=E.device) ** 2).sqrt() * 0.5 ** 0.5
y = (E * pa.sqrt()[None, :, None] * h).sum(1)
nstd = (y.pow(2).mean() / 10 ** (snr_db / 10.0)).sqrt()
y = y + torch.randn(n, d, device=E.device) * nstd
order = torch.argsort(pa, descending=True)
res = y.clone()
out = torch.zeros_like(E)
for ui in order:
u = int(ui.item())
eh = F.normalize(res / (h[:, u] + 1e-8), dim=-1)
out[:, u] = eh
res = res - h[:, u] * pa[u].sqrt() * eh
return out
# ------------------------------------------------------------------ losses --
def semantic_loss(Ehat, E, lam=0.1, active=None):
cos = (Ehat * E).sum(-1)
if active is not None:
distortion = ((1 - cos) * active).sum() / active.sum()
else:
distortion = (1 - cos).mean()
U = Ehat.shape[1]
emb = Ehat.mean(0)
ec = emb - emb.mean(1, keepdim=True)
en = F.normalize(ec, dim=1)
C = en @ en.T
off = C[~torch.eye(U, dtype=torch.bool, device=Ehat.device)].abs().mean()
return distortion + lam * off
def ser(Ehat, E, tau=0.45, active=None):
bad = ((Ehat * E).sum(-1) < tau).float()
if active is not None:
return float((bad * active).sum() / active.sum())
return float(bad.mean())
def mean_cos(Ehat, E, active=None):
c = (Ehat * E).sum(-1)
if active is not None:
return float((c * active).sum() / active.sum())
return float(c.mean())
def sample_corr(A, Bt):
"""Mean per-sample Pearson correlation across the d dims of two (n,d) tensors."""
Ac = A - A.mean(-1, keepdim=True)
Bc = Bt - Bt.mean(-1, keepdim=True)
num = (Ac * Bc).sum(-1)
den = Ac.norm(dim=-1) * Bc.norm(dim=-1) + 1e-9
return float((num / den).mean())
# ----------------------------------------------------------------- training --
def train_multitask(model, gen_fn, tasks, epochs=300, batch=64, lam=0.1,
outer_lr=1e-3, mask_lr_mult=100.0, log_every=50, tag="",
encoder=None, extra_loss=None, log_state=None):
"""Multi-SNR/-condition aggregated training (the manuscript's outer objective
without inner adaptation). gen_fn(batch) -> E ground truth on DEVICE.
tasks: list of dicts of channel kwargs incl. 'snr_db'."""
params = []
mask_p = [p for nm, p in model.named_parameters() if "mask_logits" in nm]
other = [p for nm, p in model.named_parameters() if "mask_logits" not in nm]
params = [{"params": other, "lr": outer_lr},
{"params": mask_p, "lr": outer_lr * mask_lr_mult}]
if encoder is not None:
params.append({"params": encoder.parameters(), "lr": outer_lr})
opt = torch.optim.Adam(params)
hist = []
for ep in range(1, epochs + 1):
loss_acc = 0.0
opt.zero_grad()
for t in tasks:
E = gen_fn(batch)
if encoder is not None:
n, U, d = E.shape
E = encoder(E.reshape(-1, d)).reshape(n, U, d)
ch = channel(E, **t)
Eh = model(ch["yI"], ch["yQ"])
L = semantic_loss(Eh, E, lam)
if extra_loss is not None:
L = L + extra_loss(E)
loss_acc += L
(loss_acc / len(tasks)).backward()
nn.utils.clip_grad_norm_(model.parameters(), 5.0)
opt.step()
hist.append(float(loss_acc) / len(tasks))
if log_state is not None:
gn = sum(float(p.grad.norm()) ** 2 for p in model.parameters()
if p.grad is not None) ** 0.5
log_state.append({"ep": ep, "eta": float(model.eta), "gnorm": gn})
if ep % log_every == 0:
print(f" [{tag}] ep {ep}/{epochs} loss={hist[-1]:.4f}", flush=True)
return hist
def fomaml_train(model, gen_fn, tasks, epochs=200, batch=64, lam=0.1,
inner_lr=0.01, inner_steps=5, outer_lr=1e-3,
tasks_per_step=8, log_every=25, tag="fomaml", log_state=None,
rng=None):
"""Proper first-order MAML: inner SGD on support, outer update from query
gradients evaluated at the adapted parameters."""
opt = torch.optim.Adam(model.parameters(), lr=outer_lr)
rng = rng or np.random.default_rng(0)
hist = []
names = [nm for nm, _ in model.named_parameters()]
for ep in range(1, epochs + 1):
idx = rng.choice(len(tasks), size=min(tasks_per_step, len(tasks)),
replace=False)
grads = {nm: torch.zeros_like(p) for nm, p in model.named_parameters()}
qloss_acc = 0.0
for ti in idx:
t = tasks[ti]
adapted = copy.deepcopy(model)
iopt = torch.optim.SGD(adapted.parameters(), lr=inner_lr)
for _ in range(inner_steps):
E = gen_fn(batch)
ch = channel(E, **t)
L = semantic_loss(adapted(ch["yI"], ch["yQ"]), E, lam)
iopt.zero_grad(); L.backward(); iopt.step()
E = gen_fn(batch)
ch = channel(E, **t)
qL = semantic_loss(adapted(ch["yI"], ch["yQ"]), E, lam)
adapted.zero_grad(); qL.backward()
for nm, p in adapted.named_parameters():
if p.grad is not None:
grads[nm] += p.grad
qloss_acc += float(qL)
opt.zero_grad()
for nm, p in model.named_parameters():
p.grad = grads[nm] / len(idx)
nn.utils.clip_grad_norm_(model.parameters(), 5.0)
opt.step()
hist.append(qloss_acc / len(idx))
if log_state is not None:
gn = sum(float(g.norm()) ** 2 for g in grads.values()) ** 0.5 / len(idx)
log_state.append({"ep": ep, "eta": float(model.eta), "gnorm": gn})
if ep % log_every == 0:
print(f" [{tag}] ep {ep}/{epochs} qloss={hist[-1]:.4f} "
f"eta={float(model.eta):.3f}", flush=True)
return hist
def adapt(model, gen_fn, task, steps=5, inner_lr=0.01, batch=64, lam=0.1):
adapted = copy.deepcopy(model)
iopt = torch.optim.SGD(adapted.parameters(), lr=inner_lr)
for _ in range(steps):
E = gen_fn(batch)
ch = channel(E, **task)
L = semantic_loss(adapted(ch["yI"], ch["yQ"]), E, lam)
iopt.zero_grad(); L.backward(); iopt.step()
return adapted
# --------------------------------------------------------------- evaluation --
@torch.no_grad()
def eval_scheme(scheme, gen_fn, task, n_mc=200, batch=64, tau=0.45, model=None,
B=None, masks=None, encoder=None, rng_t=None, active_fn=None,
topk_mask=None):
"""Returns (ser, cos) for one task/channel config."""
s_acc = c_acc = 0.0
for _ in range(n_mc):
E = gen_fn(batch)
if encoder is not None:
n, U, d = E.shape
E = encoder(E.reshape(-1, d)).reshape(n, U, d)
act = active_fn(E.shape[0]) if active_fn is not None else None
if scheme == "uwca":
ch = channel(E, **task)
Eh = model(ch["yI"], ch["yQ"], active=act, topk_mask=topk_mask)
elif scheme == "ofdma":
ch = channel(E, **task)
m = masks if masks is not None else block_masks(E.shape[1], E.shape[2],
E.device)
Eh = ofdma_decode(ch["yI"], m)
elif scheme == "sfdma":
ch = channel(E, **task)
m = masks
Eh = torch.stack([F.normalize((ch["yI"] * m[u]) /
(ch["h_hat"][:, u:u + 1] + 1e-8), dim=-1)
for u in range(m.shape[0])], 1)
elif scheme == "noma":
Eh = noma_sic_decode(E, task["snr_db"])
elif scheme in ("lmmse_genie", "lmmse_blind"):
ch = channel(E, **task)
Eh = lmmse_decode(ch["yI"], ch["h_hat"], ch["nvar"], B, masks,
genie=(scheme == "lmmse_genie"))
elif scheme == "tdma_proj":
Eh = tdma_proj_decode(E, task["snr_db"], rng_t)
else:
raise ValueError(scheme)
s_acc += ser(Eh, E, tau, act)
c_acc += mean_cos(Eh, E, act)
return s_acc / n_mc, c_acc / n_mc
def save_json(name, obj):
p = DATA / name
with open(p, "w") as f:
json.dump(obj, f, indent=1)
print(f"saved -> {p}", flush=True)
def set_seed(seed=42):
torch.manual_seed(seed)
np.random.seed(seed)
return np.random.default_rng(seed)
rev2/plot_rev2.py
Executable
+153
View File
@@ -0,0 +1,153 @@
"""Generate the five new revision figures from data/*.json into ../Relevance_TWCOM_R2/fig/.
Uniform geometry: 8:6 axes box, shared rcParams, no tight bounding box.
"""
import json
from pathlib import Path
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
HERE = Path(__file__).resolve().parent
DATA = HERE / "data"
FIG = HERE.parent / "Relevance_TWCOM_R2" / "fig"
FIG.mkdir(exist_ok=True)
plt.rcParams.update({
"font.size": 9, "axes.labelsize": 10, "axes.titlesize": 10,
"legend.fontsize": 7.5, "xtick.labelsize": 8.5, "ytick.labelsize": 8.5,
"lines.linewidth": 1.4, "lines.markersize": 4.5,
"figure.dpi": 200, "savefig.dpi": 300,
"grid.alpha": 0.35, "axes.grid": True,
})
AXRECT = [0.17, 0.165, 0.79, 0.80] # single panel 8:6-ish
FSIZE = (3.5, 2.75)
def newfig():
f = plt.figure(figsize=FSIZE)
ax = f.add_axes(AXRECT)
return f, ax
def save(f, name, axes=None):
f.canvas.draw()
if axes:
for ax in axes:
for lbl in [ax.xaxis.label, ax.yaxis.label]:
bb = lbl.get_window_extent()
fw, fh = f.canvas.get_width_height()
assert bb.x0 >= -1 and bb.y0 >= -1 and bb.x1 <= fw + 1 \
and bb.y1 <= fh + 1, f"label clipped in {name}"
f.savefig(FIG / name)
plt.close(f)
print("saved", FIG / name)
C = {"ofdma": "#546E7A", "blind": "#8D6E63", "noma": "#E65100",
"uwca": "#1565C0", "genie": "#2E7D32", "extra": "#C62828",
"aux": "#6A1B9A"}
# ---------------------------------------------------------------- fig_fair --
d = json.load(open(DATA / "e1_fair_baselines.json"))
snr = d["snr"]
f = plt.figure(figsize=(7.1, 2.75))
axs = [f.add_axes([0.115, 0.165, 0.365, 0.77]),
f.add_axes([0.615, 0.165, 0.365, 0.77])]
for ax, sc, ttl in zip(axs, ["HIGH", "MIX"], ["(a) HIGH", "(b) MIX"]):
v = d["scenarios"][sc]
ax.semilogy(snr, v["ofdma"]["ser"], "s--", color=C["ofdma"], label="OFDMA")
ax.semilogy(snr, v["lmmse_blind"]["ser"], "v-", color=C["blind"],
markevery=(1, 2), label="LMMSE-blind")
ax.semilogy(snr, v["noma"]["ser"], "^-.", color=C["noma"], label="NOMA-SIC")
ax.semilogy(snr, v["uwca"]["ser"], "o-", color=C["uwca"], label="UWCA (prop.)")
ax.semilogy(snr, v["lmmse_genie"]["ser"], "d:", color=C["genie"],
label="LMMSE-genie")
ax.set_xlabel("SNR (dB)")
ax.set_ylabel("SER")
ax.set_title(ttl)
ax.set_xlim(0, 20)
axs[1].legend(loc="lower left", framealpha=0.9, fontsize=7)
save(f, "fig_fair.pdf", axs)
# -------------------------------------------------------------- fig_resorth --
d = json.load(open(DATA / "e6_residual_orth.json"))
snr = d["snr"]
f, ax = newfig()
ax.plot(snr, d["uwca"]["rho_input"], "k--", label=r"input $\rho(\mathbf{e}_u,\mathbf{e}_v)$")
ax.plot(snr, d["uwca"]["rho_decoded"], "o-", color=C["uwca"],
label=r"UWCA decoded $\rho(\hat{\mathbf{e}}_u,\hat{\mathbf{e}}_v)$")
ax.plot(snr, d["uwca"]["rho_residual"], "s-", color=C["extra"],
label=r"UWCA residual $\rho(\mathbf{r}_u,\mathbf{r}_v)$")
ax.plot(snr, d["ofdma"]["rho_decoded"], "^:", color=C["ofdma"],
label=r"OFDMA decoded")
ax.set_xlabel("SNR (dB)")
ax.set_ylabel("Pearson correlation")
ax.set_xlim(0, 20)
ax.set_ylim(-0.05, 0.62)
ax.legend(loc="upper right", framealpha=0.9, fontsize=6.8)
save(f, "fig_resorth.pdf", [ax])
# --------------------------------------------------------------- fig_phase2 --
d = json.load(open(DATA / "e2_phase_iui.json"))
sg = d["sigma_phi_deg"]
f, ax = newfig()
sty = {"complexI_zerotrain": ("o-", C["uwca"], "mismatch-trained"),
"complexI_augtrain": ("s--", C["genie"], "phase-augmented"),
"complexIQ_iqtrain": ("^:", C["extra"], "two-rail (I/Q)")}
for key, (mk, col, lab) in sty.items():
ax.plot(sg, d["curves"][key]["10.0"]["ser"], mk, color=col, label=lab)
for key, (mk, col, lab) in sty.items():
ax.plot(sg, d["curves"][key]["20.0"]["ser"], mk, color=col, alpha=0.45,
label="_nolegend_")
ax.annotate("10 dB", xy=(1.5, 0.29), fontsize=8)
ax.annotate("20 dB", xy=(1.5, 0.135), fontsize=8)
ax.set_xlabel(r"phase residual $\sigma_\varphi$ (deg)")
ax.set_ylabel("SER")
ax.set_ylim(0.0, 0.45)
ax.legend(loc="upper left", framealpha=0.9, fontsize=7)
save(f, "fig_phase2.pdf", [ax])
# ---------------------------------------------------------------- fig_async --
d = json.load(open(DATA / "e4_v3_async.json"))
dm = d["dmax"]
f, ax = newfig()
cur = d["curves"]
ax.plot(dm, [a[0] for a in cur["uwca_uncorrected"]["10.0"]], "o--",
color=C["uwca"], alpha=0.5, label="UWCA, uncorrected")
ax.plot(dm, [a[0] for a in cur["ofdma_uncorrected"]["10.0"]], "s--",
color=C["ofdma"], alpha=0.5, label="OFDMA, uncorrected")
ax.plot(dm, [a[0] for a in cur["uwca_corrected"]["10.0"]], "o-",
color=C["uwca"], label="UWCA, realigned")
ax.plot(dm, [a[0] for a in cur["ofdma_corrected"]["10.0"]], "s-",
color=C["ofdma"], label="OFDMA, realigned")
ax.plot(dm, [a[0] for a in cur["uwca_corrected_err20"]["10.0"]], "^-.",
color=C["extra"], label="UWCA, realigned (20% est. err.)")
ax.set_xlabel(r"maximum timing offset $\Delta$ (symbols)")
ax.set_ylabel("SER")
ax.set_ylim(0, 1.05)
ax.legend(loc="lower right", ncol=2, framealpha=0.9, fontsize=6.0)
save(f, "fig_async.pdf", [ax])
# ------------------------------------------------------------- fig_dynusers --
d = json.load(open(DATA / "e3_dynamic_users.json"))
ks = d["k"]
f = plt.figure(figsize=FSIZE)
ax = f.add_axes([0.20, 0.165, 0.76, 0.80])
ax.plot(ks, [a[1] for a in d["fixed8"]["10.0"]], "o-", color=C["uwca"],
label="single model, 10 dB")
ax.plot(ks, [a[1] for a in d["fixed8"]["20.0"]], "o--", color=C["uwca"],
alpha=0.5, label="single model, 20 dB")
ok = sorted(int(k) for k in d["oracle"])
ax.plot(ok, [d["oracle"][str(k)]["10.0"][1] for k in ok], "s", ls="none",
color=C["extra"], label="per-count retrained, 10 dB")
ax.plot(ok, [d["oracle"][str(k)]["20.0"][1] for k in ok], "s", ls="none",
mfc="none", color=C["extra"], label="per-count retrained, 20 dB")
ax.set_xlabel(r"number of active users $|\mathcal{A}|$")
ax.set_ylabel(r"mean cosine $\bar{c}$")
ax.set_ylim(0.28, 0.47)
ax.legend(loc="upper left", framealpha=0.9, fontsize=6.8)
save(f, "fig_dynusers.pdf", [ax])
print("ALL FIGURES DONE")