From 5a0c479c1e9cde7d53b7ebc1937fb1fe6e1084b8 Mon Sep 17 00:00:00 2001 From: lepton Date: Thu, 31 Jul 2025 01:12:53 -0400 Subject: [PATCH] replicated mecc --- .gitignore | 7 + .vscode/launch.json | 15 + .../generate_data_consensus.cpython-312.pyc | Bin 0 -> 8748 bytes __pycache__/kuramoto.cpython-312.pyc | Bin 10832 -> 10831 bytes __pycache__/model.cpython-312.pyc | Bin 0 -> 7117 bytes __pycache__/train.cpython-312.pyc | Bin 0 -> 1036 bytes generate_data_consensus.py | 206 ++++++++++++++ generate_data_kuramoto.py | 162 +++++++++++ model.py | 136 +++++++++ pyproject.toml | 5 +- sims/__init__.py | 2 + sims/__pycache__/__init__.cpython-312.pyc | Bin 0 -> 210 bytes sims/__pycache__/consensus.cpython-312.pyc | Bin 0 -> 6811 bytes sims/__pycache__/kuramoto.cpython-312.pyc | Bin 0 -> 10532 bytes consensus.py => sims/consensus.py | 10 +- kuramoto.py => sims/kuramoto.py | 14 +- test.ipynb | 192 ++++++++++--- train.py | 19 ++ train_and_eval.py | 259 ++++++++++++++++++ train_and_eval_w_noise.py | 217 +++++++++++++++ uv.lock | 114 ++++++++ 21 files changed, 1304 insertions(+), 54 deletions(-) create mode 100644 .gitignore create mode 100644 .vscode/launch.json create mode 100644 __pycache__/generate_data_consensus.cpython-312.pyc create mode 100644 __pycache__/model.cpython-312.pyc create mode 100644 __pycache__/train.cpython-312.pyc create mode 100644 generate_data_consensus.py create mode 100644 generate_data_kuramoto.py create mode 100644 model.py create mode 100644 sims/__init__.py create mode 100644 sims/__pycache__/__init__.cpython-312.pyc create mode 100644 sims/__pycache__/consensus.cpython-312.pyc create mode 100644 sims/__pycache__/kuramoto.cpython-312.pyc rename consensus.py => sims/consensus.py (93%) rename kuramoto.py => sims/kuramoto.py (95%) create mode 100644 train.py create mode 100644 train_and_eval.py create mode 100644 train_and_eval_w_noise.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6a66263 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +.venv +.env +__pycaches__ +datasets/ +temp.* +test.* + diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..6b76b4f --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,15 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + } + ] +} \ No newline at end of file diff --git a/__pycache__/generate_data_consensus.cpython-312.pyc b/__pycache__/generate_data_consensus.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49ed6ec610bce271a62132869af5da9603c4d055 GIT binary patch literal 8748 zcmbU`TTmQVcDHAG-f!L@zzqVyAjCsRmV|A|SO}~aNJ4g2thD21x`7$yfw~*sF~7mOrsV8vyR$GZI3#F1`0);qb`DBh`6KfQFk8OGwR`t zyd})&?2C1{vDnsI9L<+-Cccz2^JTm(+@`~eHD3zU+KYX?HEyhi=D3x!{FEN8-c)kGu4WaU^O7V z?opl;h32Vw%I|%S`$K+8rKOu(R5c2*3Dq8(i3ZpSJ|>B(eL`TTCj-*_G_RTkUYZeN zL1R%IWPvvBZyD1<9G)#Fa`B9(}1}auUr4y)_WwT68U58EZNLXT0IGapywgpheM|sH- z=55kib-ZE?oXoqVeHHlF37>AxkuYOv{|H{>g(&jDEy7FNo5HGOW7xG53-=_C4wI=z z`Q7eEA6bHi2^2KkFe8+($nYCC+%ep?(f~_XbUX@eTd`NCQ>ZN<4?#vwUb` zlC*>ISd4%fqJJHPz*#9jFEY=Fd<4cZsUcpPjSEvhVA#k+TnI^%Q3i-JpsPX%c+JG5 zP=t{td5sbi5}5+=4m+WHg{ZaIOFCH6K1Q0Ej_?>!VneY|Y=RJoX`JSmLHtfI@v$(7 z&`ySmykl&XZzmF9o-7w;gM2JF&qP^}XHHwlkm}$CE-nTHJ~khk(6;m0sfX|uiagJ$ z?paon#DFLX@d;L1c#hR`;urUD`P);fXN(otF;)x(*vJ?!NYC+^tKRAOEH6aZ*+4Kd zBTBsR9KTZVVw*Vp^7gBbO4d;musAsm)RAtLkTT9mIN>W*;Cy%yYaqeF^ zw??gXulH;?PvsF?pW0eAM2B<9{^6-#8CUvN7S{S6{5Z|Ly4*(?G%3!emC-fddg+Gq z4VY&yOI5W!wYL=+WWRfIv*K)C39mJ*U0w(I`jQlgZZc=+GKDVt6~B5eec;%?l^1wU<;OSZ6Pv!$jIUAgHLi3&e(Upd56^A*jxC;h=5Qv%%WWw~Q;Kf-pBENX zaYDq$_K#LaKW!E2p&86yLC{19pDWhGtxw^37llxQl2Ld&2F8M-+ogm7#_^0@r7(^! z8H%G`hjF-YD9%7y2F^Iu4=QBkXxX>`TxG+81ECnjVH^|2k+3YJgt5fCii{rRr2>5O zF8sYr!FGJhF8sZ&^X>T7UHHyj!a#S2Jhol9As5HfTnHO%q~>u%1AcpxWKD|@S;W#S?$gqk&D2IL_0C|BdJEG-h>3~*Wx|g zHRl?-&CjAa<25u(?V4fB&mcUn!MaC~j_I#to8dJehVV2S3C=_`d#%}1@cppCLgg&@tGLG1xp&8p24Oc+pQooEySn6a)Etr*R65r zR!EwMo@Ttjk}wkl|1)o0#c43U0vp*z3yV`Q^qQqTP581z-Uzr2 z{Meow@u>Uq zbPEs|i-L_K{&>AksJKxu%#V+Uf+0XqEB1yz{}xM8t4|gu;{u$96qshE$v}jUO-Pff zl?#FI0-gg%7X+sTpC(8*Bw+tC^b+(!EswC%5jGfNV*zm0_}DErG6M^*0QZL<6WCBt zUj{kN=kMe7Vq56K znBDks7^9m-ydF+1Daxnm$4peUotX>r(^vykOKcABWmGMV#Aj}SXGeNiy+9L%SAmk> zOl+8H$*YHI!?BQdyriieY!7DY&~+0g6CeM?pKl ztMDR^Z*ef|^<}&bink%{-M@HtXAg{Z$44Qh32WZzv%wE#ENg_+Jm~a z>Zc98sVgIRuvVe#HtU)D;d|j#-^bC#!Q_xa?|W%RuQc3`-;1xZ>H4lbaPv@S=FoZN z(D^U=(uaodWWPeU0cv+ort6H-b><11?s^-;+ZFoIW^3E$u7|EQHr;w0!eMpEAHJHjq`V!9wG+!Tb#H35;p14+vSe4R`!*Y! zKI?qYxz>DwM9balc)09?Ch9vwZ31hi~Kz zwCm7jeRHP%gi?QEz2V9JjrxHl$7XA1rnOgT?OpF)pGvo$Te2)W6>oE{3^_{|hjK2| z>`x9ZT~M42m=XrrPLkV)bX4CXm~ySnHlSN*0Iy`(-ooR=+?7+tF-i zk1k!d>j)7n4T70q=zm|9pt8Cbh;kjuwzgy5Pl2~rV^j*zZ$+$N|I~VLU_bij>aKy; z(XaQH4xBLl`Z$H3ue%4`#(!~9@KlX(IjdHz!D1*Xsy6WH1H>l}(m+Bl*c-wg*VYg` z?jlKtqrC$5aKVczpkd2K$%b)*Y;=H6_LzE3T}UNCL)C(+6&~xfUpaTA>iGZ#}n~2vxvTS zxIgOspf}^FQyg_!t0U{FT&_vEo3h^Or*PRE&k@fiRBE1ObEr%;0zliJcpE`8?yjcN5Tl>G-pbfiq20lx3QOt ztGmzzC&(-n9NX|7F6&;o2H9MgZIKFY=$^BEy4=NDHgo0$=sqsw9}-pxn*dTct41NbCtQo&gb z7hEfS4npCA6Ig@+507m782!?qQ%l&T@0ZH{T~ZY@FtR~kBRIZ)#l3$-8TV+?cN$(YF zcwbH)FFe&QE%SCI>v zbsg`IB~dE%=qPe2tmJ^+E7sq!KG$C9SN&>Bl>LF7KUSo#w`8AOCcE_gN|b*m-@Ro# zuG1;jK%uwT(^~*NqPL4RKyk#es{r)mE)aCNvQI2>iR=yc{r@ptf8?_79WDR9QLg+G zQ=;OJcj)nRW_Le>b)3MlEwl*%z_cARDhR&9&kYKd(b0G*N;!_LWVI1W|BFrU7TngY7 z4v32xG=Z^Z)SlfMjgj2TKZVE>d9ljN%a+X4+kXUp$XNc_nJFLd~u1Z;U!BgA5=F$94ejaMz42cU2Pk612U85%s# z&kMD<=ivBp795uV{$6967Vr#1TvV-5c8Z5R5e4ivs5Fl6R5~0F#UQmze87TMsGifh zf08aO@t&d}8nwSo+f z1TLMq64*ANmT!Y=6!2`-J#zMdcIf<$Uw1ZJ?+QEmoIn}K-ajHLn`({`<-ZpH4wcNFqO78X0Ldlt=;rSX!4p9A8b!oTy9ReHfwv<`qH(pCNE~& zjwCNGLx|Y|6k88|w(wvf({fB{IkxUhx150le)7U{+h*MxS#Qnq!2RKS!>jLR4xLmE zoqS@>ym?7^^U{{lQ11qj?WmTyfAZeR%)Zx@eXp$#eKC}}K9=4WOkT*j(SCoXu}5j_ z$ub8%^E~im542|vyrvv@E!)tNY3NoOx{HlGhE{#!u^lLZAhxkH+ti(DI<7PwPdD{u z8@n=%$CSon>BbXTrai;-C`?b9Ir>eVr^=mt`(+cV-gn<}&vM^+&$)7a?cMdWPlD^G zzGzPMTuN76PM+QLl`n->O4GjP9E7ahtG-Qd8CH+w)|I|h_DgTq?~MTd29LeCLBZkV zY;f8y;S+$#o^l>rx39@hPNeJ?zodtLZ_zQo6|rUe*PiP0ZI<7(na&?^sMY{n)bQ#C z{I3X8FeuF72mW+M?nu=JFIWe8omCU51Obnc%hIZUxYN>2b$Yj>@YPQ2&~rKS@Wo00 zjtJ(a02bcBb#sR1rAxEj2$hSk)G>AVELduELZqR0oK;ztL z{xa<&AHz)KLzs4_;&&J?6n{bt1Rf$`7<0nD_qW#9Ndk>ODcpxH{!$@+1&^GOqNuNs z?JMLUfA-&@%CAt#SE&5oQD+Ku{tlG`JZC*XHLo;&=6?XHb5vuhR_%Z!DUv2ZF9Pu&zVH{VxozMmRmsRAmqxVuJzlHB(M(uW!r~T2dQozgqK2v5y9Pu%lM7Fc)xV{! NKO4vy5nV$T|9?`Fb=3d> literal 0 HcmV?d00001 diff --git a/__pycache__/kuramoto.cpython-312.pyc b/__pycache__/kuramoto.cpython-312.pyc index 9ac356390db23b2ae69141709bca9653cab5b112..c1fdca7ae8bd43aacfc1ebbb27471197f5a17f01 100644 GIT binary patch delta 123 zcmcZ*az2FjG%qg~0}x~~v}fGj$ji)b$`!?%%9F~L!eavzPT`8;1M_%6yj1=azEsvU zrWF1bmen9#KoBKRDWEAh*_FLs%MYD$>pv902$~Xe*gdg delta 124 zcmX>fav_BGG%qg~0}#x#Y00>?k(Zg>lqZTel_!-gh1UisoWc{u2j=mCc&Yp;{Hd&I zOeq2_EUQ7ffFMesQczQ9vMYPNc*rf`y!@iv#GK5k)cB;z_>|Q2qSREk&9~T9nK)H1 Ru!zqPxy+)nnS;w+0RU^sAVL5D diff --git a/__pycache__/model.cpython-312.pyc b/__pycache__/model.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..196000194add0819007af4c22a30cff2eee89af6 GIT binary patch literal 7117 zcmb_gS!^3en(ijMn>Qt1x_nWxte8He*s^3R_9m9?$dWC2;>hDeYlqWfHzmrv+}*Mc zH?a&5AXH$$6lND<5C>sic4^o^^r!(A7|-s*2-p|)&@ZZO|p@rPN7wdqlAy1f6wfNG!zY? z(+kb>qF0*ay)%4hVp0;laP(euSkN4bdRcEc6y;gL8)oNtp%c%1fi?`6!$d;SyKw$Y zgq=ktc}*q9eYAj1Ri(vvI3%h1sc2lK#5;nd8m6P6U`&Yk%z^<%2nrMqh~7U8?XycCZ`y8<9BT@wNupY#iS zAU1)v7>oL6{H!EJyCO)II^%PyBLp3OZDW4CF`)&>B8J4fkR^$iZo=KNbZYTbR$p+n ze>|LgKh?8tt$Q%IFqpoazPEU*VBMR1f8A(*U|+DOr!)6*!};BPPkWwr08DCrkw}HI(S> zDM71UTeUW?aKafLQVB+804T=!Q?CJq4Trs0jJ#MTd5IUqPVa|2sGTT4#~YuM1fJJW zg3efFG+2SUqQyxz&c8r6GvFh!%=;*{o}J*MlAn)^^Bfn7PKc^W0_`V;S&3IoNNoLa zAvUE_lRV4$j2K&j15=IymH>6;=yb%7sfem=la8MYMX*q-rcg8v+7P}~GpNOK-Dl81 zxD$~wA?V?$str}E9N^C?7e>^JI1!p)o`_&v2BOf62pKT2f>EIhzILD?e-9bJ$xQUU z_iO8~tWQT*TMH+K6{;sWluBeGx$7k(Ve|a$-KE50B70-`Zt?h_a(r;Lqj=#X<-$k# zUjMVkUzGH^-R74J(ePF_u^cS+4k*0?t4wk5rZRZ5;JLN#>CoCQD7_a}`|}@MEq=f$ z@EhjxG3l9SdcD3iyFWKjJak$)boyyW@yw`lX0%X$<$IgK&Ljs)PQvO;jtGcfyf3v* zJ2EL0;YEp$i-EG3!T_RbH~tZW5yS~Mzna~I85-;m9MRcuI+TMQ*rYYJ9S9i!5GCuj z17dI!a7aLbt{&5+P(BZ|5{4Su+dx(}a5Tp}F;qkyTQXz91eS;3jIYw#Y%yW#h;uWt zBU76|ho*Ak%s|&tp^7-E;bS{hKs_$oQe+_$7HJcXQ%J*aNmJlpZB4QT@1v~b5?0wN zoAC+QWE*g9eQhsVOLZ@H*$x1=&2t#3*vEKF^n!7kVFk_`oQ?*N-RSgQVQ*_@5E;lS z;<1ec8Ih*Fn=*39E0ncBT;RD7CLm(+LL2Ze>_J&O%8*SHS|NM!Kad`gD#gx*L}4## zMh76EeZ4?OB%%vCAosg;4aUsTX0ald!QcT#7+Oaawltw%z@&Y<9FuUxms*6Td zgBS}+V4r<;ShR(=(G(1N^EfL7CjBBf0K!{n4(V4dHQGqEZQ|Y!dP5~|tK=P(ysMg_ z-7f}W$kDQ(df9VO>$M8c`PsX?0HjoN%~_yrmz71OC@YQfxeEg@;xPQh|As6{fM#fY zyXfsv;79FBUPzlW{m-3E`R0R)^HA=(;_OXcTz7hk&Nju_mOZ)LvNE>XP#n6Y4Bg7V z{ZYZ`PhNcP-jnUf?NHi!mIF%LJBs_A!R9L@!lmZOUC=e%>C$d<5`$6~Ij6&+ab z*A;@k#^RU30+TnBtlvfu!g!+~jJ7d0QX0yhNBFnFj@p7Vk7P=wxF&LN{3dt)NeHgE*ffZRnVCTTn zB4b$w-KK#Sg?CZwdnh{%8HQ4{jH}lzYyAW-Aum?jo*zu?Fib)dMF}!MiTYheLVrE@DfLK^ zfU3h~!kKXB2=Gb_vQc)(PPo~!gkkT?kT51(a-Hm&x54bX`+F$@zHHd%a3c>wwxcsa z6sLA++}Gx^yRtqB(fQQw+CHr=w90nQI1eA3X&ypij=T*9S!j@eTP<`)8h}Mmgi<+ZmIUGRc?HS=zI2K^T;=7&Y-kUH>JOWvgSZ~;s zVY7|7jzYtclx4ln`CxWo_M!eO!{>&qB{u>7Orfc_PV>0)hpZ4(dkm3!x}H4~AnCsuME5wk2re1-MV_-T0dEEej)v{w0(l zPK6IphAg^j#Lo@zCZTy)?X^K_5}{VL=Zh82b>g(0CoyDojVCXdCE2RFf78 z!8nziRmnLafaaMsmhcD)T(78Vgy$caF(C>_hJ;DTL}Wjz((_8~^y#uF)ku%O>wv9T|>!X$iCZu zI2SH<_A8zJh5cv#U^|;Vl4jC((t%Vsb4Ic6&fCr=2OxvMCmsCdLGThC4QaX9ctB}9 zP;ealfvBgCrs%cCmXvk9d3WYsp&8mJ)4tTunyWeEQ(W!YiCjqOIFY)O>i^dR2rHpg z$7=uT-NJ#ZiuJA3Kzb-MyJl_53@X<4h2fG3CYP*4LtFNu;^|76*NpD;-3*_(miO#a zj2%VeVa0ejH}%Ze_uSH0wCwqvWl#3!xyxVQSZ-6=kFAiuYwugPI?@C18teG{c=l-K zP&Tw|Ug^$vy_a{MerD~*({>arJF;}nTHJqLfuHyM>XCwXc-^%ZqPKy9t2=dW&FV~F z&AgvEo_Fm9&WhH9iuGXb-0!VNO0BTxQU}qzZ_U}X*5Li#K-DwJL0}rDoXA^t)gYuDA0FFpsYM3-ZFy9Hn2`|?)E;I{AW3dvD z9Tkuc*MMrmuNSdcSj4zg>3$T1sCtApY8=|}s~|?UN}+cO&1Rx#0?XzjLbFFmuK!{@ z1;%bV%)cuv!YA^&#ot0!(vu|lC&K(K(eN$N_-Eq4p9t%>#4gxi%kJ+@4$`@1tAB7~ z;YLXh_2-_Z5)CD&#m1JB0o9Czt8oL3D|OV9&a`W(d9k@fKs9@D0~Muq2icH5S0bRu zb$`?Ms1H|HZf~HLQiq*v&s-@HP~=W-prYhGLGH|0N(2HV%6hFt8@1`v!Oj8o(y*YZ(dIhKV|Xdk($Psp{urjjTp75lL9rEh%pAXCpyAfRqVd6#P1_Nh|s zBqc$6N-mqmI7JLOmW!O!d(+La8D?oWwQEjX+sVWX$1Lq+W0sk+T+FgD%Q<;gFnM`k zgF?L+6%T~V{5`>syv_s$jtaaV5ZYl}tH}#+lvvPWuIup*alK$-c7dY2$9sJZJSvF3 zp4s`f;EHk8SJ8sJ6a)fXiFhZgNA%SrFKG<`FeCSg@Igwc?Z+l!v z3xrV4g^p_|LS)_?$s)iUzvsR^+-`E| mp2>$M4lc5S0e;(-W&K2(S2%4wx tuple[nx.Graph, str, np.ndarray]: + """ + Generates a random, undirected, unweighted, connected graph. + It randomly selects a NetworkX algorithm and retries until the graph is connected. + + Returns: + A tuple containing the networkx Graph object, the algorithm name, and the adjacency matrix. + """ + + G = None + + + if graph_type == "erdos_renyi": + + # p = 2.0 * np.log(num_agents) / num_agents + p = 0.5 + G = nx.erdos_renyi_graph(num_agents, p, seed=rng) + + elif graph_type == "watts_strogatz": + k = 2 + p = 0.1 + G = nx.watts_strogatz_graph(num_agents, k, p, seed=rng) + + elif graph_type == "barabasi_albert": + m = 2 + if m >= num_agents: m = max(1, num_agents - 1) + G = nx.barabasi_albert_graph(num_agents, m, seed=rng) + + elif graph_type == "powerlaw_cluster": + m = 3 # Number of random edges to add for each new node + p = 0.1 # Probability of adding a triangle after adding a random edge + if m >= num_agents: m = max(1, num_agents - 1) + G = nx.powerlaw_cluster_graph(num_agents, m, p, seed=rng) + + # Add self-loops, as they are often assumed in consensus algorithms + G.add_edges_from([(i, i) for i in range(num_agents)]) + adj_matrix = nx.to_numpy_array(G, dtype=np.float32) + + return G, graph_type, adj_matrix + +def calculate_graph_metrics(G: nx.Graph) -> dict: + """ + Calculates and returns a dictionary of key graph metrics. + + This function computes basic properties, connectivity, clustering, + community structure, and spectral properties of the graph. + Computationally expensive metrics are skipped for larger graphs to ensure performance. + """ + metrics = {} + num_nodes = G.number_of_nodes() + num_edges = G.number_of_edges() + + # --- Basic Properties --- + metrics["number_of_nodes"] = num_nodes + metrics["number_of_edges"] = num_edges + metrics["average_degree"] = (2 * num_edges / num_nodes) if num_nodes > 0 else 0 + metrics["edge_density"] = nx.density(G) + + # --- Connectivity --- + metrics["is_connected"] = nx.is_connected(G) + metrics["number_connected_components"] = nx.number_connected_components(G) + + # --- Clustering --- + metrics["average_clustering_coefficient"] = nx.average_clustering(G) + metrics["clustering_coefficient"] = nx.clustering(G) # Per-node clustering + + # --- Distance-Based Metrics (for connected graphs) --- + # These are computationally intensive and only run on smaller, connected graphs. + if metrics["is_connected"] and num_nodes < 250: + metrics["average_shortest_path_length"] = nx.average_shortest_path_length(G) + metrics["diameter"] = nx.diameter(G) + metrics["eccentricity"] = nx.eccentricity(G) + else: + # Set to None if graph is disconnected or too large + metrics["average_shortest_path_length"] = None + metrics["diameter"] = None + metrics["eccentricity"] = None + + # --- Spectral & Community Metrics (Potentially Slow) --- + # These are also limited to smaller graphs. + if 1 < num_nodes < 500: + # Eigenvalues of the Laplacian matrix + try: + laplacian_eigenvalues = sorted(nx.laplacian_spectrum(G)) + metrics["laplacian_eigenvalues"] = laplacian_eigenvalues + # The second-smallest eigenvalue of the Laplacian matrix + metrics["algebraic_connectivity"] = laplacian_eigenvalues[1] + except Exception: + metrics["laplacian_eigenvalues"] = None + metrics["algebraic_connectivity"] = None + + # Modularity using the Louvain community detection algorithm + if num_edges > 0: + try: + communities = nx_comm.louvain_communities(G, seed=123) + metrics["modularity"] = nx_comm.modularity(G, communities) + except Exception: + metrics["modularity"] = None # Algorithm may fail on some graphs + else: + metrics["modularity"] = None + else: + metrics["laplacian_eigenvalues"] = None + metrics["algebraic_connectivity"] = None + metrics["modularity"] = None + + return metrics + +def generate_multiple_initial_states(key: jax.Array, num_sims: int, num_agents: int, max_range: float) -> jax.Array: + """Generate a batch of unique random initial states for the agents.""" + return jax.random.uniform( + key, + shape=(num_sims, num_agents), + minval=-max_range, + maxval=max_range + ) + +def main(): + """Main script to generate and save the consensus simulation dataset.""" + # --- Configuration --- + GRAPH_GEN_ALGOS = ["erdos_renyi", "barabasi_albert", "powerlaw_cluster", "watts_strogatz"] + AGENT_COUNTS = range(5, 51, 5)# 5, 10, ..., 50 agents + GRAPHS_PER_AGENT_COUNT = 100 + GRAPHS_PER_GRAPH_ALGO = GRAPHS_PER_AGENT_COUNT // len(GRAPH_GEN_ALGOS) + SIMS_PER_GRAPH = 100 + OUTPUT_DIR = "datasets/consensus_dataset" + + # --- Setup --- + seed = int(time.time()) + main_jax_key = jax.random.PRNGKey(seed) + numpy_rng = np.random.default_rng(seed=seed + 1) + + print(f"šŸš€ Starting data generation...") + print(f"Saving dataset to directory: '{OUTPUT_DIR}/'") + os.makedirs(OUTPUT_DIR, exist_ok=True) + + # --- Main Generation Loop --- + for n_agents in tqdm(AGENT_COUNTS, desc="Overall Progress"): + agent_folder = os.path.join(OUTPUT_DIR, f"agents_{n_agents}") + os.makedirs(agent_folder, exist_ok=True) + + for graph_idx in tqdm(range(GRAPHS_PER_AGENT_COUNT), desc=f"Graphs for N={n_agents}", leave=False): + graph_algo_idx = graph_idx // GRAPHS_PER_GRAPH_ALGO + + # 1. Configure the simulation using the imported class + config = sims.consensus.ConsensusConfig() + + config.num_agents=n_agents + config.num_sims=SIMS_PER_GRAPH + + # 2. Generate graph and its metrics + G, graph_type, adj_matrix_np = generate_connected_graph(numpy_rng, config.num_agents, GRAPH_GEN_ALGOS[graph_algo_idx]) + adj_matrix_jax = jnp.array(adj_matrix_np) + graph_metrics = calculate_graph_metrics(G) + graph_metrics["graph_type"] = graph_type + + # 3. Generate initial states for the 100 simulations + main_jax_key, states_key = jax.random.split(main_jax_key) + initial_states = generate_multiple_initial_states( + states_key, config.num_sims, config.num_agents, config.max_range + ) + + # 4. Run all simulations using the imported JAX function + trajectories = sims.consensus.run_consensus_sim(adj_matrix_jax, initial_states, config) + + + + # 5. Package all data into a dictionary for logging + log_data = { + "simulation_config": { + "num_agents": config.num_agents, + "num_sims": config.num_sims, + "num_time_steps": config.num_time_steps, + "step_size": config.step_size, + "max_range": config.max_range, + "directed": config.directed, + "weighted": config.weighted, + + }, + "graph_metrics": graph_metrics, + "adjacency_matrix": adj_matrix_np.tolist(), + "initial_states": initial_states.tolist(), + "trajectories": trajectories.tolist() + } + + # 6. Save the complete log to a JSON file + file_path = os.path.join(agent_folder, f"graph_{graph_idx:02d}.json") + with open(file_path, 'w') as f: + json.dump(log_data, f, indent=2) + + print(f"\nāœ… Data generation complete! Check the '{OUTPUT_DIR}' folder.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/generate_data_kuramoto.py b/generate_data_kuramoto.py new file mode 100644 index 0000000..7cd4524 --- /dev/null +++ b/generate_data_kuramoto.py @@ -0,0 +1,162 @@ +import os +import json +import time +import jax +import jax.numpy as jnp +import numpy as np +import networkx as nx +from tqdm import tqdm +from functools import partial +from dataclasses import asdict +import sims +# --- Import necessary components from your Kuramoto simulation file --- +from sims.kuramoto import ( + KuramotoConfig, + run_kuramoto_simulation, + phase_coherence, + mean_frequency, +) + +from generate_data_consensus import generate_connected_graph, calculate_graph_metrics + +# ============================================================================== +# SECTION 1: BATCHED OPERATIONS FOR EFFICIENT DATA GENERATION +# ============================================================================== + +@partial(jax.jit, static_argnames=("config",)) +def run_batched_simulations( + thetas0_batch: jax.Array, # (num_sims, N) + omegas_batch: jax.Array, # (num_sims, N) + adj_mat: jax.Array, # (N, N) + config: KuramotoConfig +) -> tuple[jax.Array, jax.Array, jax.Array]: + """ + Runs many Kuramoto simulations in parallel for the same graph but different + initial conditions, and performs analysis. + + Returns: + A tuple containing: + - All trajectories (num_sims, T, N) + - Final coherence R(T) for each sim (num_sims,) + - Mean frequencies for each sim (num_sims, N) + """ + # Create a batched version of the simulation runner using vmap. + # This maps the function over the first axis of thetas0_batch and omegas_batch. + vmapped_runner = jax.vmap( + run_kuramoto_simulation, + in_axes=(0, 0, None, None), # Map over thetas0, omegas; adj_mat and config are fixed + out_axes=0 + ) + all_trajectories = vmapped_runner(thetas0_batch, omegas_batch, adj_mat, config) + + # Analyze the results in a batched manner + # phase_coherence naturally works on the time axis, so we vmap over the sim axis. + vmapped_coherence = jax.vmap(phase_coherence)(all_trajectories) # -> (num_sims, T) + final_coherence = vmapped_coherence[:, -1] # -> (num_sims,) + + # vmap the mean_frequency calculation over trajectories and omegas + vmapped_mean_freq = jax.vmap(mean_frequency, in_axes=(0, 0, None, None)) + all_mean_freqs = vmapped_mean_freq(all_trajectories, omegas_batch, adj_mat, config) + + return all_trajectories, final_coherence, all_mean_freqs + +def generate_batched_initial_states(key: jax.Array, num_sims: int, config: KuramotoConfig): + """Generates a batch of initial states.""" + keys = jax.random.split(key, num_sims) + + # We will just write a new generator that is vmap-friendly + @jax.vmap + def generate_single_state(k): + key_theta, key_omega = jax.random.split(k) + thetas0 = jax.random.uniform(key_theta, (config.num_agents,), minval=0, maxval=2 * jnp.pi) + omegas = jax.random.normal(key_omega, (config.num_agents,)) # Using std=1, mean=0 + return thetas0, omegas + + thetas0_batch, omegas_batch = generate_single_state(keys) + return thetas0_batch, omegas_batch + + +def main(): + """Main script to generate and save the Kuramoto simulation dataset.""" + # --- Configuration --- + GRAPH_GEN_ALGOS = ["erdos_renyi", "barabasi_albert", "powerlaw_cluster", "watts_strogatz"] + AGENT_COUNTS = range(5, 51, 5) # 5, 10, ..., 50 agents + # AGENT_COUNTS = [50] + GRAPHS_PER_AGENT_COUNT = 100 + GRAPHS_PER_GRAPH_ALGO = GRAPHS_PER_AGENT_COUNT // len(GRAPH_GEN_ALGOS) + SIMS_PER_GRAPH = 100 + OUTPUT_DIR = "datasets/kuramoto_dataset" + + # --- Setup --- + seed = int(time.time()) + main_key = jax.random.PRNGKey(seed) + numpy_rng = np.random.default_rng(seed=seed + 1) + + print(f"šŸš€ Starting Kuramoto data generation...") + print(f"Saving dataset to: '{OUTPUT_DIR}/'") + os.makedirs(OUTPUT_DIR, exist_ok=True) + + # --- Main Loop --- + for n_agents in tqdm(AGENT_COUNTS, desc="Agent Counts"): + agent_folder = os.path.join(OUTPUT_DIR, f"agents_{n_agents}") + os.makedirs(agent_folder, exist_ok=True) + + for graph_idx in tqdm(range(GRAPHS_PER_AGENT_COUNT), desc=f"Graphs for N={n_agents}", leave=False): + + graph_algo_idx = graph_idx // GRAPHS_PER_GRAPH_ALGO + # 1. Setup config, keys, and graph + config = KuramotoConfig() + config.num_agents=n_agents + config.coupling=1.5 + config.T=15.0 + main_key, graph_key, state_key = jax.random.split(main_key, 3) + + G, graph_type, adj_matrix_np = generate_connected_graph(numpy_rng, config.num_agents, GRAPH_GEN_ALGOS[graph_algo_idx]) + adj_matrix_jax = jnp.array(adj_matrix_np) + graph_metrics = calculate_graph_metrics(G) + graph_metrics["graph_type"] = graph_type + + # 2. Generate a batch of initial conditions + thetas0_batch, omegas_batch = generate_batched_initial_states(state_key, SIMS_PER_GRAPH, config) + + # 3. Run all simulations and analyses in a single, efficient call + trajectories, final_R, mean_freqs = run_batched_simulations( + thetas0_batch, omegas_batch, adj_matrix_jax, config + ) + trajectories.block_until_ready() # Ensure computation is finished + + # 4. Package all data for logging + log_data = { + "config": { + "num_agents" : config.num_agents, + "coupling" : config.coupling, + "dt" : config.dt, + "T" : config.T, + "normalize_by_degree" : config.normalize_by_degree, + "directed" : config.directed, + "weighted" : config.weighted, + }, + + "graph_metrics": graph_metrics, + "adjacency_matrix": adj_matrix_np.tolist(), + "initial_conditions": { + "thetas0": thetas0_batch.tolist(), + "omegas": omegas_batch.tolist() + }, + "results": { + "final_coherence": final_R.tolist(), + "mean_frequencies": mean_freqs.tolist() + }, + # Optionally save full trajectories. Warning: can create large files. + "trajectories": trajectories.tolist() + } + + # 6. Save the complete log to a JSON file + file_path = os.path.join(agent_folder, f"graph_{graph_idx:02d}.json") + with open(file_path, 'w') as f: + json.dump(log_data, f, indent=2) + + print(f"\nāœ… Data generation complete! Check the '{OUTPUT_DIR}' folder.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/model.py b/model.py new file mode 100644 index 0000000..a8de801 --- /dev/null +++ b/model.py @@ -0,0 +1,136 @@ +import jax +from jax import random +import jax.numpy as jnp +from train import ModelConfig, TrainConfig +import optax +from functools import partial + +def init_linear_layer( + key: jax.Array, + in_features: int, + out_features: int, + use_bias: bool = True + ): + + """ + Initializes the weights and biases in a linear layer. + """ + key_w, key_b = random.split(key) + limit = jnp.sqrt(6/in_features) + W = random.uniform(key_w, (in_features, out_features), minval=-limit, maxval=limit) + params = {'W': W} + if use_bias: + b = random.uniform(key_b, (out_features,), minval=-limit, maxval=limit) + params['b'] = b + return params + +def init_fn(key: jax.Array, config: ModelConfig): + """ + Initializes all model parameters. Returns a pytree + """ + + key_embed, key_translate, key_attn_proj, key_head = random.split(key, 4) + + params = { + "agent_embeddings" : { + "weight" : random.normal(key_embed, shape=(config.num_agents, config.embedding_dim)) + }, + "translate": init_linear_layer(key_translate, config.input_dim, config.embedding_dim), + "attn_proj": init_linear_layer(key_attn_proj, config.embedding_dim, 2 * config.embedding_dim, use_bias=False), + "head": init_linear_layer(key_head, config.embedding_dim, config.output_dim) + } + + return params + +def forward(params: dict, input_timesteps: jax.Array, config: ModelConfig): + """ + Model's forward function. Takes in the parameters and inptu timesteps, returns predictions + """ + batch_size, num_agents, _ = input_timesteps.shape + + agent_embed = params["agent_embeddings"]["weight"] + agent_embed = jnp.broadcast_to(agent_embed, (batch_size, num_agents, config.embedding_dim)) + + attn_proj_out = agent_embed @ params["attn_proj"]['W'] + k, q = jnp.split(attn_proj_out, 2, axis=-1) + v = input_timesteps @ params["translate"]['W'] + params["translate"]['b'] + att_scores = (q @ k.transpose(0, 2, 1) )/ jnp.sqrt(num_agents) + att_weights = jax.nn.softmax(att_scores, axis=-1) + weighted_average = att_weights @ v + prediction = weighted_average @ params["head"]['W'] + params["head"]['b'] + + return prediction + +def get_attention_fn(params: dict, config: ModelConfig): + """ + Calculates and returns the learned attention matrix between agents. + This is a pure function for analysis. + """ + embeddings = params['agent_embeddings']['weight'] + + # Project embeddings to get keys (k) and queries (q) for the global graph + attn_proj_out = embeddings @ params['attn_proj']['W'] + k, q = jnp.split(attn_proj_out, 2, axis=-1) + + # Note: Using sqrt(embedding_dim) as in the original get_attention method + attn_scores = (q @ k.T) / jnp.sqrt(q.shape[-1]) + + return jnp.asarray(attn_scores) # Return as NumPy array for logging + +def train_model(config: ModelConfig, inputs: jax.Array, targets: jax.Array, + true_graph: jax.Array, + train_config: TrainConfig, + ): + + key = random.PRNGKey(0) + key, init_key = random.split(key) + params = init_fn(init_key, config) + + optimizer = optax.adamw(train_config.learning_rate) + opt_state = optimizer.init(params) + + def loss_fn(p, x_batch, y_batch, config): + predictions = forward(p, x_batch, config) + loss = jnp.mean(jnp.abs(predictions - y_batch)) + return loss + + @partial(jax.jit, static_argnames=['config']) + def update_step(params, opt_state, x_batch, y_batch, config): + # FIX 1: Pass all necessary arguments to the loss function here. + loss_val, grads = jax.value_and_grad(loss_fn)(params, x_batch, y_batch, config) + + updates, new_opt_state = optimizer.update(grads, opt_state, params) + new_params = optax.apply_updates(params, updates) + + return new_params, new_opt_state, loss_val + + loss_history = {f"epoch_{i}": [] for i in range(train_config.epochs)} + # FIX 2: Initialize with empty lists `[]` instead of `None`. + graphs = {f"epoch_{i}": [] for i in range(train_config.epochs)} + num_batches = len(inputs) + + for epoch in range(train_config.epochs): + running_loss = 0.0 + for batch_num in range(num_batches): + x, y = inputs[batch_num], targets[batch_num] + # FIX 3: Pass the `config` object, as it's a static argument for JIT. + params, opt_state, loss_val = update_step(params, opt_state, x, y, config) + running_loss += loss_val + + epoch_loss = running_loss / num_batches + loss_history[f"epoch_{epoch}"].append(epoch_loss) + + if train_config.verbose and (epoch + 1) % 10 == 0: + print(f"Epoch {epoch+1:3d} | Loss: {epoch_loss:.6f}") + + if train_config.log and epoch % train_config.log_epoch_interval == 0: + attn = get_attention_fn(params, config) + graphs[f"epoch_{epoch}"].append(attn) + + all_logs = { + "loss_history": loss_history, + "graphs": graphs, + "true_graph": true_graph, + } + + return params, all_logs \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index d19e634..aafb930 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,6 +10,9 @@ dependencies = [ "jax[cuda12]>=0.7.0", "jupyter>=1.1.1", "matplotlib>=3.10.3", + "networkx>=3.5", + "optax>=0.2.5", + "scikit-learn>=1.7.1", "seaborn>=0.13.2", "tqdm>=4.67.1", -] \ No newline at end of file +] diff --git a/sims/__init__.py b/sims/__init__.py new file mode 100644 index 0000000..9909fda --- /dev/null +++ b/sims/__init__.py @@ -0,0 +1,2 @@ +from .consensus import * +from .kuramoto import * \ No newline at end of file diff --git a/sims/__pycache__/__init__.cpython-312.pyc b/sims/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c9ce2da66fba1f3c3ab73e4da78a6352ff1ddb4 GIT binary patch literal 210 zcmX@j%ge<81j%!|G7Nz9V-N=hn4pZ$5y%+HH2k54Qq$eXwRQ}?y$<0qG%}KQ@ d;slxnva^^QNPJ*sWMsUWO+oUfO0Fx3$IH^DW6Y$lR{Ub1T(8X1}_}ytjE>F~&_f z3x?{X`Y{q(kz|4m_wn6{AY=I@(GC* z0pB3xlGqR@yJe5$+6$u+7xL1coAx{*-~q<&TQPf-Y)<^591|v3$AD@*Acche;#yAZ1o_E$i4 zi!4D+e%iZjC>E8ssj?Z5Y1_gvN!~W7i}4`=c#jQg3a%_%5=7I~w&7&}iF0wC@ucp- z<*@R>-*_FW_sIj6b^8`Qq-j<9a3(y?V57-8s$>16gL7_KI%#_DK>)p zmX(r~@tVpC%xChNI|7n60^`zSR>Cpd>of^+q6UYc;(A8BARD~Mqcrh@%0*e@%^{hG z>k`AV7Ebc^rSYOB(SdM6*FlVVdWSFz?vPIyiZ;j>zHLD%I;*Pa9={ZIkWW+AZ4KG_ zq(UbYKNi26kBGyaUAitN`HrF%{emyHgLDomY8MjoA|(cPOi|I0vx)~oJ;s3|+js?? zg|%qI<_7iF5tqlX^GqyMxVqvdwiNCzLdyXvmIZd~Zbc00b}-1f?NhRu(6wi{>aBF~ zL>!=5mTYvgPx-$b(pj!lK5QY-(d?cHvKA)}D~9E}Aj@$HFd^u+ToEm9xr{{Aa*6#0 zg&oTSau-dgLASmZ=IQIOYJudl&@+QOHl(5QF7%O?06=b=iI z#qGr3nC`k$U3ax-yytfZCVH;--01pk@8rqpm2=g*(gzoO{>&TWfppis>Qy&(&9B*# zTeIbM__N5Z$V~mrTeF?Lxi!7H>fUcoW>21*KPl$mcU;T``m2$$HSp9xA#KAr@;!+IM7n=*oYcBHuh3a#T3e20k*@kQNsDtar>10 zEu1@~Yk`~SHikqv5=!qO^coc{u7Xh-w7>hkeLCt|uo~b)9JW06C0O2sroc&}wl}i@ zD6E$2nAfLEYe9MlPmITLj0L6~KOO#oMQ{00M68LrDl8y<`T zl_m7zK#+uj#dOH^T|oXK{EZ2y(&XVLva)4j_x0WLjnCy8pPLL%KR>_oKyK%Oug}gO zJexasHoN0ow(+^y#=i8?haS?{Jm0V}*RXN&=yd(e!MTS0>7xsQ`m6gs*mtLS^@MU= znGAdy&ha~@cT9`3%`asF_q;V%-uuma3w5noU+eb`O%om0J8tZmZFu4K#?Lx#bxiO1 z;+4-|`Fj2A=I&fWH!jwk<(esQJ%U*U*XK{b_0No16&#oW#GMNG6hP#w@E#D(aj+ci zW<{-ByNk*V<{#q>$4$vweA^G_pQ7kg3ZFq;Z7Yg;RI0DwuKeE>){aE}8-+!#sf63U z@G_l6pZ!r!%hpYoz6GQMY_y_X6jijbSbY%Zvl>ua-;5)JA%PpS&=+o+r4?)4#9&@{A*t0P9-!WZylY0 z7(|A~3cBruf-Vjzh8fe7Xedj9hG#d31wC@Uz%nVd_4!dbMaj;WpCc+LFj3*_KZc=V zOn{6$fr&gymE6wHV!$0dz}YA=y%)FcR*$IFX)PuMWLQaBSicl7JF)GGsfMB^)a2_}#ENV2fVfjq} zL?a$EWFSV~^;fY%M)e-7x}kz}0(cZQc1TPXNsj68Ay% z6UDB!^&j`$?EAAe6U+9!Ikzs9Ev`;dVJ0`{1Ku4DASZ>jgHFRB;THy*HsR?N{l|-3Q7Lu0O zW+D0DiXc^4nR5C}sn1@)Ca1`hgKm(};3`EC6k*(>o)VwFQY_&vtm6g$zP^kd=$3GV z(n(9olb_X1-sS zx%@s1Qs4q*1ya7wJx~gi&9VYM4MwwNh59-b-sfW(x>|eLBzKVS~enrwi>Zj}Evh_RFf}I|J!Ps*~0B5DI=m9$628LlN~8DvdpO(4PooE@QeP z8^H#v9-R8P8Z%X;A98-!vOLbyYsg}MOxGasDVqZ1VxqFeLMFgX6F82G0jVQMl3E@J zz96cy+;*3<7aF!1^d#*kmsFLglfg6=eODSAb*;{>HaZrO91x<9FQZ z1)h$E}8(=E$8u&DEF3U%vL{Y@j{e zeGjJeUhW+`cBiTJ#_rjs=YJrK`v{ZqFZcpiedE4sE3aMrNSs`KL(R2pnLaynWM)tH z#h#4s@4mx}E~JD^s@sQ4WJcy7M`|yZd3TO$!}j6Jhcg57wQafDwrow?q-UPrp5wRA zaXWDE$mJv1+8uM;PG{EGF=xvAy%b}D^){CJF#?5TTs#SR8GPs);Lui}knooc9pT6F z4+h0v-;stNJylHG0|M1z>sltv+%P^)-b^kMY|ps9@_*^K z+u!V4qVE>>u47t0-S}DXR&bF(b4FOg$Kq>DBhxY&{)_U7vPhsg)4qg{2b&4&&oo|b x8E=_#)%vvrYO#RT)aKy$|UD)}XB2+iy%@dtb^xd_`y>6UgiFm?1`{{hv;bF=^e literal 0 HcmV?d00001 diff --git a/sims/__pycache__/kuramoto.cpython-312.pyc b/sims/__pycache__/kuramoto.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5937fb566d194846ff46c790d4d0ab2fa28620c GIT binary patch literal 10532 zcmd5hTWlLwb~EJgDN!=@pq`OOvLuVLEcq47QW7h+62D^0uIwf;on$iBjA+snDbEaT zkxMo7ZcYN$c9Ea< zoI4znQm7wnB~St# zpgh`>9y551G{S}eGiLIb2y6_P$1ENTf$4z3V&F5=^%Z8f8zZ zff6ku<*(PL%s&P59gB`9SOKRoKc+*1ZG(RM2K^;ssZd&cY}76|US)1)NqfrwU#+aH zU}c-W=gP{9?^D>cLH`dsGiSldoIttQO;&6$<3=~Z2$cm?E57G`t2UVB|8~FC1uLr* zTpP^!ZG2`HYF=eLRW?f4_HFNvGD7XECQr3cC0hMmI>+aqLfr=aF!!igsE0Xf#9E=@ zVh2S{)6zaT#ZsYBctmKt({$UY(ec#5`uF5%>X5%zhw@Kh^KDvdc^Wr(>#;nx4vCEd zt4r|sv5?bCi z>Z?NiB09xpu|;Ho4x{0D+Qc^hiTpb{q{}&ZYm2aD4V4P9O>cX)0@X^fZ5`DPvaVJg zD@&zK+$vCYFon?m7W1}Y-RM>r?bvYCy%rnjTm8fOYV%LAMaR>h*||H{wl{pgL&wvf zmMOzdsnZ8O-387>s*d?A)(E*f7v#m1Ha%5ZOq*aEkNV$8HTJ}s>;>SWtXfPBU z^?9Q^v?p{bzEF@I4N0tWL1c9-b}S@_0ao^ng#!em`vKZo)gBCwalBUyD)N6o8%kzC zwT^_s;{jjL>-|yH-yZ%f`s#pc5EQRA-uk3UpHc0KZ%pK5MI4t8sg=QyG{y&fQIR_z z;RMkuiK1#1e3Ce#h=OXpBKo`+02+dITRASs!>gQX=QvnYIDl{|$6X5Zf$WHdH6SV&%Z94BukThe83V9NU|qx>&o(rKdu_quZB2pmd}SK`MnaIn^pH|WE|o2udm6Q(p%wOU>oKM)W9U+{0Gx~`exfV^@{2f#b0#iW65;Mmvf+-3_P+);74Rn#m)|HqU z*NAwhDYrR%4FEd}WiT{09#%w|NTDD~zRPfFmqj)-N_xgG@UlpxROCl4upxQG7XZNw zN!{da;Wu|VUyq=$Pq4q8;(Y8jw&NMLhXv8%d_m6VW;@y6yubHfB#wJ>HThtYV-%kRZCF3LPl|CsuAcw6&@oZ zL`2MOm6~8k+Kd&86=5qAC=+10O}e7s#L-a@c3CaW^#B>w28-3yfs7Z2=YmCQfQDMB zix!~h$0K#aNEQ6$zkn)EWvVDg#hY7Zx6N$(`K9UZRB7|V)4yoGbNc;rx6Ungr&{|` zrG4?IGghj0^K4`$^6u{UdT;hFKKjo7RL#yLQ}vaZs;Zgoo#{+LPMao2uEDD7{~@X?pMMz|6qH3#rPT zsS+T#lZfORVM6vL!t{3l%u;zKi&4NbhL};e{vZkzuuu^Ji!nM2O`2jRB_}S$L<1R3 zpuYnL84}j@9atbFz_Nzuz$sAzb1^2fJTj6uAhJ(`R+d=MyP(R6#${2{>%6`OBH$gQdtvKD!VY9@+QE`H5;0oUkjhHJ)I zDq%<%6ZEK2pkK94GT*Kf{ctJkOAJ^-FiaVXT{P&TEF+-%IcWk7WQOZvqCX?TJsb|= zeT{|#fxL~+TX&*ac-9LVCkXclW{n5q4|YTBwrlSbvmp1A2A;Yi@qUotkQC`>JI-{m zLvEIrBtC+dt|==XSwm(+mw`3V`fHkMq>!QU3M=9Numh^UgcB+hhbhyPaf;D*HE96h z0ILFfqQNU8*PG=RmFA?~Kp?Mgq`lD886+N$YYN07kMKcmG#KrW!a*+2EqNd3@jz&V z56JtwvzW(_4C=E##;H%LTNWN&Y$xnfeK28PEw7vFPnNeOt!;!K&{Z@C#GqHX;ATKu z@)N2t02PC@h@;`QNRQ$&ad8D}?Z;*xRKVT2LzOMi!M^T5PwwDcrkJ^_Du z0IIL!)PL3+OzmIUv)XF*_{{NDYdQIqu9jD?l(VUFHe;izn;%l9YV*|-;B7=RrBtaa z$y95cZPqw@BxiJiFkThWTYnBf;YAhGPy!vJP)FU)QkbOk7yARuJ6&k7b(+ZB;q5R1 zVaYY-(;En#2mTF7U?^B{*um>j02=NB2^bT3IV=&oswyI8T?+ufy033}Rmf%s@*K`0Kd z7qT=%fH=XCW0Pf+W1Tn4NgtOxO6dp;J`aBx zH83dOTFO;7``pZPbHfYm^XJml?)cE>C1uxpr+VMqJ-csa-`vnr1(@4($)ic;QNn~0 za&vK&8iSGV;=sHu6X-jJoU_LmC{&{BEUigFX(Pp7++j4{VRRb6cc$nY-()&GD|S>8 zFNJ}bh#Fkysbw`GTxnkKe%s|EK@JH5S9J_^73kMBQ~5+$qXPGbcQQ1Dn#cm46h9$q zZk%?#Ch2h)R+-CV{J3U(@w%l$P=O-F<6ftk)Cxo$7li_cOD*REfr7TIYuTKhD$A{# z9E61C_X7N7oE=!9k*a^>M(upJM9jP>RuqPwI zC%_;3ruI#r1aGUPE6H?ey2*G^jI6OCXeWtc`X%TBh)!rfbgVDB^_Vomc%cQ#B1+A9 zhAC!U{kHWKF}49`ElX>X2|oG1qae^1pMvNHL(_Fd$wd) zb{!UjB6yDAF7UcfDe*xeG{!=7%8w9-bI3cm4QhDqz;o5f$A8ANQ)DEyf+l& z18$Ra66VvQ8hS`I$rt!>Q8jCelaU!g5_G-DLZXE1i_=!X<#t0NZr_CT0=)2N@R#3# zDo)+EmaSOpQr5cofmKJ@G@UpUe;Oi?Yp?wHl~0^iv-LCeE6yz`=az-R#p<-PXUYsw zNu_JHbEb2pqBT{~x^Q~2EnTr=X?Ln(?}~GO%DMkn@<06O?|+nbK9extFL7QUczxh= zAXGb3JJ+6eHorUg-jSO}7N33p`CHE~T}nfI0r<=pyvzrX-zMM*(Kc#T36rhBijad-G~Pdry+pn5#38emaC6%V znAc9C77n$wYSUm@5mX!KSC0698c0T@vq&%Jyvlgegw6A;?#i)xc3+U}1A&%C0rd^| z%dbEM>fcN?Zobh!-@nqZE!D7XaWLJmBgNFlk0v6kdEN)C@`~&JDgR0tn<`@$>K6ZG z@u|DcdprM8{-?{ozWnR{WEq<-8;T!>fUT@{&i(Gld;XjLmG<6Ld+%M_y#x35q}z|A z>W`!xN04tTrVk|slGy~AY8>X25#(6C;BE*9+o8t%Rxt}gc+&_PF85|JM;07kLowck z-Xe}gP7j)toZc_Sov1YhMljtm>(LNdjhWPzNvo3M#k@9uih2<~giP9E7Qa*9X#NRl zgZw^Kq^U_@>I7WKB_j$L07P5rcwpol<4o% zh*6{W=bu998VpPwt}B8`a0q30%Jnk?N{q1SVmCD6nS(Yhiyg^D|sx-fa}gS}Q0Fc9`~qwFUZ+vOLF_lF z-p+Q>Q~_Sgx8X%B?)vDyQ-P2oXXE)?oB>*iXe-bXZ1GU5Kxq;4>^3|=C*}dlz!^|u z7We`oL;7DegZY%iiJ`1D|KmW^d;k=Q!UB>Za78r*`14{Q+MY`xoy;XZ*;6DXdPWbK zVO7yhtuJ6|^97>6Ag|dPHEiGR-A&3L27smwzEX%_`vanC;sc<0B{W~rk}$Zr5-Z_n z2hgMNZ6W~3M#u)J*3l4r>%g_r7opEI5(#VXe%4k150<* zdIqDg4%r=LhC39u_h0`7OJ=}bA$fq3YJk+L6_zHCga4wr9cB2TCI8VxHI4@q)hdV2 zkK>i7CU7XcqRL=P>OdMcSybQ!1-52KFhY(_WxSG4z{CU`tDuccXd_k)%QvQ$D!6ej zz(+!11rin)LRZ{&Eh4~+A)d+V8VdBJ2tahn3@==KM2@^6}+MIRB zW-qF7q4}JPB+B7{B1^9W>R-cOeg>QeNZ*GHt9K+I(6=& z$>iY|6V~5ZU&xA&*%ghs5!qYHGlMe5N zZ#oDczj}PSdHT$B-7?dF?X`1$&RABMsuWYT%(y<$MqfLo#Y*t)Y>bCMkb8g*z4zzy zSRM?xjhd5y_e8GsK_@^D&>%!vNE8Mksk>p4Flr;&1i8DrJ6d%*mpWs$>;U8oqjmP} z+qXj=gbzeyNKg!GSIt6awDxE=wV0C)cDQ4QyPu63yZ4MnYY+M0E%+3Y&By=~4R@S@ zVQCQ776x5U*@v<&(xGgmjmoIww^Q!^Xp8*>hTw$*B=?wKWWU>xRWz`1wEFH&EkLkA zwyqllZakuz$U}<^N^)O*A&|!7QEj8)AS69Q0a;?8EnUV=CpiDe-T~iv`09s{YSx}o z1d+^$Wc2$$wH&|{sTO?i!J#LyI)W93$s`&e9us_M5lA|fNQi_MT$4iL=~+$<4;_9+ zjA-86%P^>Y#RJz3)Bw6&9D;WJ%O1oTIp0k+jZ2WImnM)T2K}n@Jm|TLTsWxs0`OUr z7b0rOFo#D+^bbV*m%Stpf$=;XH_Rn#YeU1NC2P?9erEVr+E77Zg^tl);v$yk0X^v#@QM?#>wM=v{O2jmUf? zLjkzDxrM++fbTcAzE^j%E@J{1#HzU`W6_{Jy&v{{(Dx;_9vUe_48gXfn1rBj99Q`r5p_z8$x!$>e(+#pp_+#{d*{b=~~Uz znvB6g@0}aGadiG@h5~SL%lqzI?k^EUY#SN>qG|mmE9mX|@d3D+-Ix*J``~;dF%!VB zs>aTYMT2^Fz3;o_`x0B(bzpyIC0(J-nV|r@`x1F1Pn}*lbvAYC>_hC#bWwZzzA%>3 z4GYHiY&UHg3c#iP5Al&{s;A2r&ZBdlp#WTxK8$`4CE!PZ0X><1iYZM*)5f~b91RQ7 z(%{`)%Z~l=L#uYj_0Flz6?E!DQ>cq`hyM>Cbgn+~k%{CtG1&G$n-g zRRrw^BdXIoEQdbG~!Ildj*f)Vb91 ZVdn>(ch9AF9sOwU@0j7t6I3?Z`5(s#AbS7+ literal 0 HcmV?d00001 diff --git a/consensus.py b/sims/consensus.py similarity index 93% rename from consensus.py rename to sims/consensus.py index 176edc4..b82defd 100644 --- a/consensus.py +++ b/sims/consensus.py @@ -10,7 +10,7 @@ class ConsensusConfig: Config class for Consensus dynamics sims """ num_sims: int = 500 # Number of consensus sims - num_agents: int = 5# Number of agents in the consensus simulation + num_agents: int = 5 # Number of agents in the consensus simulation max_range: float = 1 # Max range of values each agent can take step_size: float = 0.1 # Target range for length of simulation directed: bool = False # Consensus graph directed? @@ -61,6 +61,10 @@ def generate_random_adjacency_matrix(key: jax.Array, config: ConsensusConfig): config: ConsensusConfig Config for Consensus dyanmics + Returns + --------------------- + adj_matrices: jax.Array (num_agents, num_agents) + Random matrix """ rand_matrix = jax.random.uniform(key, shape=(config.num_agents, config.num_agents)) # idxs = jnp.arange(config.num_agents) @@ -90,7 +94,7 @@ def generate_random_agent_states(key: jax.Array, config: ConsensusConfig): Returns --------------------- - rand_states: jax.Array (num_agents, 1) + rand_states: jax.Array (num_sims, num_agents) """ rand_states = jax.random.uniform(key, shape=(config.num_sims, config.num_agents), minval=-config.max_range, maxval=config.max_range) @@ -113,7 +117,7 @@ def run_consensus_sim(adj_mat: jax.Array, initial_agent_state: jax.Array, config config: ConsensusConfig Config for Consensus dynamics """ - + # batched consensus step (meant for many initial states) batched_consensus_step = jax.vmap(consensus_step, in_axes=(None, 0, None), out_axes=0) def step(x_prev, _): diff --git a/kuramoto.py b/sims/kuramoto.py similarity index 95% rename from kuramoto.py rename to sims/kuramoto.py index e613c9c..baa67c9 100644 --- a/kuramoto.py +++ b/sims/kuramoto.py @@ -5,26 +5,18 @@ from functools import partial import numpy as np import matplotlib.pyplot as plt -# -------------------- Configuration -------------------- -@dataclass(frozen=True) class KuramotoConfig: """Configuration for the Kuramoto model simulation.""" num_agents: int = 10 # N: Number of oscillators coupling: float = 1.0 # K: Coupling strength dt: float = 0.01 # Ī”t: Integration time step T: float = 10.0 # Total simulation time - - # Adjacency matrix properties - normalize_by_degree: bool = True + time_steps: int = int(T/dt) + normalize_by_degree: bool = False directed: bool = False weighted: bool = False - @property - def num_time_steps(self) -> int: - """Total number of simulation steps.""" - return int(self.T / self.dt) -# -------------------- Core Dynamics -------------------- @partial(jax.jit, static_argnames=("config",)) def kuramoto_derivative(theta: jax.Array, # (N,) phase angles omega: jax.Array, # (N,) natural frequencies @@ -88,7 +80,7 @@ def run_kuramoto_simulation( scan_fn, thetas0, None, - length=config.num_time_steps + length=config.time_steps ) return trajectory diff --git a/test.ipynb b/test.ipynb index 8c8e1eb..8b7114b 100644 --- a/test.ipynb +++ b/test.ipynb @@ -5,7 +5,19 @@ "execution_count": 1, "id": "c883f5e2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'consensus'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjax\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mjnp\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mconsensus\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m *\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'consensus'" + ] + } + ], "source": [ "import jax\n", "import jax.numpy as jnp\n", @@ -14,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "e3c2fa64", "metadata": {}, "outputs": [], @@ -25,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "04880fb1", "metadata": {}, "outputs": [], @@ -42,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "acc686b9", "metadata": {}, "outputs": [ @@ -56,7 +68,7 @@ " [1.7320508]], dtype=float32)" ] }, - "execution_count": 4, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -67,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "2685d249", "metadata": {}, "outputs": [ @@ -83,7 +95,7 @@ " [-0.900332 , -0.08470678, 0.72673416, -0.75884247, 0.8060036 ]], dtype=float32)" ] }, - "execution_count": 5, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -94,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "01d95cba", "metadata": {}, "outputs": [], @@ -104,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "23b2ac73", "metadata": {}, "outputs": [ @@ -112,7 +124,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|ā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆ| 500/500 [00:01<00:00, 359.94it/s]\n" + "100%|ā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆā–ˆ| 500/500 [00:01<00:00, 356.10it/s]\n" ] } ], @@ -137,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "ff65a64f", "metadata": {}, "outputs": [ @@ -147,7 +159,7 @@ "500" ] }, - "execution_count": 8, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -158,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "9db9c2b7", "metadata": {}, "outputs": [], @@ -168,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "6584c0b2", "metadata": {}, "outputs": [ @@ -262,7 +274,7 @@ " 1.28308088e-01, 1.18334584e-01]]], dtype=float32)" ] }, - "execution_count": 10, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -273,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "620a7701", "metadata": {}, "outputs": [ @@ -283,7 +295,7 @@ "(500, 100, 5)" ] }, - "execution_count": 11, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -294,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "b094224e", "metadata": {}, "outputs": [ @@ -356,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "eaf34907", "metadata": {}, "outputs": [ @@ -366,7 +378,7 @@ "Array([ 0.88282514, 0.4825251 , -0.07153511, 0.03161097, 0.97659564], dtype=float32)" ] }, - "execution_count": 13, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -378,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "faa4b66f", "metadata": {}, "outputs": [ @@ -392,7 +404,7 @@ " [-0.0937705 , -0.49407053, -1.0481308 , -0.9449847 , 0. ]], dtype=float32)" ] }, - "execution_count": 14, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -403,7 +415,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "4d025175", "metadata": {}, "outputs": [ @@ -413,7 +425,7 @@ "Array([3, 3, 3, 4, 2], dtype=int32)" ] }, - "execution_count": 15, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -432,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "dcf551fc", "metadata": {}, "outputs": [ @@ -440,30 +452,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "Running Kuramoto simulation for 2000 steps...\n", + "Running Kuramoto simulation for 10000 steps...\n", "Simulation complete.\n", "\n", "--- Analysis Results ---\n", - "Initial Coherence R(0): 0.3215\n", - "Final Coherence R(T): 0.8273\n", + "Initial Coherence R(0): 0.1514\n", + "Final Coherence R(T): 0.8072\n", "\n", "Natural Frequencies (ω):\n", - "[-0.7398006 -0.604128 -0.20279019 0.44994825 -0.46915287 -1.2962328\n", - " 0.21116947 -1.1270597 0.52725625 2.3874943 -0.81883216 0.7570075\n", - " 0.05850044 -0.18476951 1.1620507 1.8633609 0.87869114 1.6664302\n", - " 0.9078429 -2.4709177 ]\n", + "[-0.7398006 -0.604128 -0.20279019 0.44994825 -0.46915287]\n", "\n", "Mean Frequencies over Simulation:\n", - "[ 1.46405891e-01 -3.69619280e-02 1.12412088e-01 1.85934424e-01\n", - " -2.74336944e-05 -4.56956811e-02 7.81505778e-02 1.00682445e-01\n", - " 5.45639619e-02 2.78184921e-01 3.78948152e-02 2.49829754e-01\n", - " 5.42316996e-02 5.19525371e-02 1.47024721e-01 6.63236454e-02\n", - " 1.17484398e-01 2.30125502e-01 9.03259367e-02 -6.20467544e-01]\n" + "[-0.73979986 -0.22966443 -0.196503 -0.18220069 -0.21775451]\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -474,7 +479,7 @@ ], "source": [ "from kuramoto import *\n", - "config = KuramotoConfig(num_agents=20, coupling=3, T=20)\n", + "config = KuramotoConfig(num_agents=5, coupling=2, dt=0.01, T=100)\n", "key = jax.random.PRNGKey(42)\n", "key, adj_key, state_key = jax.random.split(key, 3)\n", "\n", @@ -510,6 +515,115 @@ "execution_count": null, "id": "70037c87", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[1., 0., 0., 0., 0.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 1., 0.],\n", + " [0., 0., 1., 1., 1.],\n", + " [0., 1., 0., 1., 1.]], dtype=float32)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adj_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a0cd55f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8791633", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWh1JREFUeJzt3Xd8VfX9x/HXvTe5N3sRMgiBsIdAkDCMe0RxVMVVtCoULVqLrW3skA6obS22jrqoKEq1+lOoVm2timJUFEXBALKRHVYWkL3vPb8/Tu5NAgkQSHJyk/fz8TiPe3Jz7r0fbpHz7nfaDMMwEBEREbGI3eoCREREpHtTGBERERFLKYyIiIiIpRRGRERExFIKIyIiImIphRERERGxlMKIiIiIWEphRERERCwVYHUBJ8Lj8bB//37Cw8Ox2WxWlyMiIiInwDAMSktL6dWrF3Z7y+0ffhFG9u/fT3JystVliIiIyEnYs2cPvXv3bvH3fhFGwsPDAfMPExERYXE1IiIiciJKSkpITk723cdb4hdhxNs1ExERoTAiIiLiZ443xEIDWEVERMRSCiMiIiJiKYURERERsZTCiIiIiFhKYUREREQspTAiIiIillIYEREREUspjIiIiIilFEZERETEUgojIiIiYimFEREREbGUwoiIiIhYSmGkLdRWweePQ8EWqysRERHxOwojbeGzh2HJLFh4M7jrrK5GRETEryiMnKryg/Dl0+b5wa2w7jVr6xEREfEzCiOn6osnoKYMHE7z56V/AXettTWJiIj4EYWRU1GWDyueNc+vmQchsXB4J3zzqrV1iYiI+BGFkVOx7DGorYCksXDatXD2z8znlz4EdTWWliYiIuIvFEZOVskB+Pp58/yCX4PNBuNuh7AEKM6B1f+0tj4RERE/oTBysj57BOqqoE86DLjQfC4wGM651zz/9BFzyq+IiIgck8LIySjaA6teNM+9rSJeY6ZARBKU7ofsFywpT0RExJ8ojJyMzx4Gdw2knAP9zm36u8AgOPfn9dc9AjUVHV+fiIiIH1EYaa1DO2H1y+b5hb9t/prRt0BUHyjPh5XPdVxtIiIifkhhpLU+fQg8dTDgIuhzRvPXBDjhvF+Z558/BtWlHVaeiIiIvzmpMDJ37lxSUlIICgpiwoQJrFixosVrzz//fGw221HHFVdccdJFW6ZwW8MaIhf85tjXjroRYvpDxUH46pn2r01ERMRPtTqMLFq0iMzMTGbPns2qVatITU1l4sSJ5OfnN3v9G2+8wYEDB3zH+vXrcTgc3HDDDadcfIdb+hcwPDD4UuidduxrHQFw3n3m+RdPQlVx+9cnIiLih1odRh599FGmT5/OtGnTGD58OPPmzSMkJIQFCxY0e31MTAwJCQm+Y8mSJYSEhPhfGMnf3LDvzAW/PrHXjLweYodAVVHD/jUiIiLSRKvCSE1NDdnZ2WRkZDS8gd1ORkYGy5cvP6H3eP7557nxxhsJDQ1t8Zrq6mpKSkqaHJb7ZA5gwLArITH1xF5jd8D59a0jy+dCxaF2K09ERMRftSqMFBYW4na7iY+Pb/J8fHw8ubm5x339ihUrWL9+PT/4wQ+Oed2cOXOIjIz0HcnJya0ps+3lroONbwE2OP8EW0W8hk+CuNOgugSWP9UOxYmIiPi3Dp1N8/zzzzNy5EjGjx9/zOtmzpxJcXGx79izZ08HVdiCj+eYj6ddA/HDW/daux0umGmefzkPygvbtjYRERE/16owEhsbi8PhIC8vr8nzeXl5JCQkHPO15eXlLFy4kNtvv/24n+NyuYiIiGhyWGb/atjyDtjscP7Mk3uPod8xu3Zqy+Hzx9u2PhERET/XqjDidDpJS0sjKyvL95zH4yErK4v09PRjvva1116jurqaW2655eQqtcq6183H066FnoNP7j1stoapwCufh6pOMAZGRESkk2h1N01mZibz58/nxRdfZNOmTdx1112Ul5czbdo0AKZMmcLMmUe3IDz//PNMmjSJHj16nHrVHcm7YFnc0FN7n0GXQOxgs3Vk3b9OvS4REZEuIqC1L5g8eTIFBQXMmjWL3NxcRo8ezeLFi32DWnNycrDbm2acLVu2sGzZMj744IO2qboj1VWbjw7Xqb2PzQZjb4PF98HKBTD29qYb7ImIiHRTNsMwDKuLOJ6SkhIiIyMpLi7u+PEjr30fNrwJlz0EE+44tfeqPAyPDIW6Krh9CSQfeyCviIiIPzvR+7f2pjkeb8tIgPPU3ys4GkZcZ55/3fwicSIiIt2NwsjxtFU3jdfY28zH9W9oETQREREURo7P1zLSRmEkKQ0SRoK7umHTPRERkW5MYeR43G0cRrwDWcHsqun8Q3ZERETalcLI8bR1ywjAyBvAGQYHt8Guz9rufUVERPyQwsjxtPWYEQBXOIz6rnmugawiItLNKYwcT1t303h5u2o2vQ1l+W373iIiIn5EYeR42qObBsxBrL3HgacOVr/Utu8tIiLiRxRGjqc9umm8vK0j2S+Ax9327y8iIuIHFEaOx11jPrZ1ywjAaddAUCQU5cD2j9r+/UVERPyAwsjx1FWZj+0RRgKDYfTN5rkGsoqISDelMHIsHrc5pgPap5sGIM3c7ZhvF0Px3vb5DBERkU5MYeRYvONFoH1aRgB6DoaUc8DwwKp/ts9niIiIdGIKI8fi7oAwAjC2vnUk+0Vw17bf54iIiHRCCiPHUlc/eNVmB3tA+33O0CshJBbKcs3uGhERkW5EYeRYvINXHS5zT5n2EuCEMbea5xrIKiIi3YzCyLG057TeI42ZCtjMKb6HdrT/54mIiHQSCiPH0p7Teo8U0w8GXmSeZ7/Q/p8nIiLSSSiMHIt3zEh7Tes9kndF1tUvN53JIyIi0oUpjBxLR7aMAAyaCBFJUHEQ1r/RMZ8pIiJiMYWRY2mvHXtb4giAcbeb51/NA8PomM8VERGxkMLIsdR14ABWrzHfh4AgOLAG9nzVcZ8rIiJiEYWRY2k8tbejhPaAkTeY51/N67jPFRERsYjCyLH4pvY6O/ZzJ9xpPm78LxTv69jPFhER6WAKI8fiG8Aa1LGfmzAS+p4NhhtWPtexny0iItLBFEaOxTu91tHBLSMAZ/zQfMx+AWorO/7zRUREOojCyLH4umk6uGUEYMjlENkHKg/Butc7/vNFREQ6iMLIsfi6aSxoGbE7YPx081zTfEVEpAtTGDmWjl6B9UhjboXAEMhbD7s/t6YGERGRdqYwcixWDWD1Co6GUZPN8y+ftqYGERGRdqYwcixWTe1tbEL9QNYt78Lh3dbVISIi0k4URo7FO5vGqpYRgLih0P98MDya5isiIl2SwsixWDm1t7EJd5mPq16EmnJraxEREWljCiPH0tEb5bVk0CUQ3Q+qimHtImtrERERaWMKI8fiG8BqcRix22H8Heb5V89omq+IiHQpJxVG5s6dS0pKCkFBQUyYMIEVK1Yc8/qioiJmzJhBYmIiLpeLwYMH8+67755UwR3K6qm9jZ1+MzjDoGAz7PjE6mpERETaTKvDyKJFi8jMzGT27NmsWrWK1NRUJk6cSH5+frPX19TUcPHFF7Nr1y5ef/11tmzZwvz580lKSjrl4tuduxMMYPUKioTR3zPPv3rG2lpERETaUKvDyKOPPsr06dOZNm0aw4cPZ968eYSEhLBgwYJmr1+wYAGHDh3irbfe4qyzziIlJYXzzjuP1NTUUy6+3flm01g8gNXL21Xz7WI4tMPaWkRERNpIq8JITU0N2dnZZGRkNLyB3U5GRgbLly9v9jX//e9/SU9PZ8aMGcTHxzNixAj+/Oc/43a7W/yc6upqSkpKmhyW6AxTexuLHQQDLwYMWDHf6mpERETaRKvCSGFhIW63m/j4+CbPx8fHk5ub2+xrduzYweuvv47b7ebdd9/ld7/7HY888gh/+tOfWvycOXPmEBkZ6TuSk5NbU2bb6SxTexvzLoK2+mWoLrW2FhERkTbQ7rNpPB4PcXFxPPvss6SlpTF58mR+85vfMG/evBZfM3PmTIqLi33Hnj172rvM5nWWqb2NDbgQegyC6hLIfsHqakRERE5Zq8JIbGwsDoeDvLy8Js/n5eWRkJDQ7GsSExMZPHgwDofD99ywYcPIzc2lpqam2de4XC4iIiKaHJao64RhxG6Hs35inn/xJNRWWVuPiIjIKWpVGHE6naSlpZGVleV7zuPxkJWVRXp6erOvOeuss9i2bRsej8f33LfffktiYiJOZyfq/miOr5umE4URgFE3QmQylOXB6pesrkZEROSUtLqbJjMzk/nz5/Piiy+yadMm7rrrLsrLy5k2bRoAU6ZMYebMmb7r77rrLg4dOsQ999zDt99+yzvvvMOf//xnZsyY0XZ/ivbSmab2NhbghLPuMc+XPdawHoqIiIgfCmjtCyZPnkxBQQGzZs0iNzeX0aNHs3jxYt+g1pycHOz2hoyTnJzM+++/z89+9jNGjRpFUlIS99xzD7/61a/a7k/RXjrb1N7GTr8VPn0YSvbCN69C2lSrKxIRETkpNsPo/GuLl5SUEBkZSXFxcceNHzEMuD8aMODebyE8/rgv6XDL58L7v4boFLg7GxytzpYiIiLt5kTv39qbpiXuWqA+p3WmAayNpX0fQnrA4V2w/t9WVyMiInJSFEZa4h0vAp03jDhDIb1+7M1nD4On5YXkREREOiuFkZY0HhTa2WbTNDZuurlvTeG3sOm/VlcjIiLSagojLamrX7/DHmiu7dFZBUXAhLvM808fhkZTqEVERPxBJ77LWqwzrr7akgl3gjMM8tabm+iJiIj4EYWRlnTG1VdbEhID46eb558+ZM4EEhER8RMKIy3prKuvtuSMGRAQDPtXwfas418vIiLSSSiMtMRdP4DVH1pGAMJ6wtjbzPOlah0RERH/oTDSEu8AVn8JIwBn/hgcTtjzJexaZnU1IiIiJ0RhpCXeqb2OTrgUfEsiEs1l4sEcOyIiIuIHFEZa4msZ6WSb5B3P2T8FewDsXAp7VlhdjYiIyHEpjLTEn6b2NhbVB1JvNM/VOiIiIn5AYaQl/jS190hnZ4LNDls/gP2rra5GRETkmBRGWuJvU3sb6zEARlxvnmf90dpaREREjkNhpCX+NrX3SOffZy5lvz0Ltn1odTUiIiItUhhpiT9O7W2sx4CGVVk/mKUdfUVEpNNSGGmJP07tPdK5vzB39M3fAGtesboaERGRZimMtMRfp/Y2FhID5/7SPP/oT1BTbm09IiIizVAYaYlvaq8ft4yA2VUT1RfKcuGLp6yuRkRE5CgKIy3xdtP4c8sImGNeMn5vnn/+OJTmWlqOiIjIkRRGWuLtpvHHqb1HOu0a6D0Oasvh4wesrkZERKQJhZGW+Kb2+nk3DYDNBpfUh5DVL0PeBmvrERERaURhpCVdYQBrY30mwPCrwfDAkllWVyMiIuKjMNKSrjC190gXzTYXQtv2IWzLsroaERERQGGkZb7ZNF2kZQSaLoS2RAuhiYhI56Aw0pK6LjK190jehdDy1mshNBER6RQURlrizxvlHYsWQhMRkU5GYaQlXW0Aa2NaCE1ERDoRhZGWdKWpvUfSQmgiItKJKIy0pK4LDmBtrPFCaFl/tLoaERHpxhRGWuIbM9IFW0bAXAht4p/N8zUvw65l1tYjIiLdlsJIS3xTe7vYANbGksfD2NvM87fvgdoqa+sREZFuSWGkJXXdIIyAOXYkLAEOboPPHra6GhER6YYURlrSVaf2HikoEi5/yDxf9jfI22htPSIi0u0ojDTH4wFPrXneVQewNjbsShhyBXjq4O2fmH9+ERGRDnJSYWTu3LmkpKQQFBTEhAkTWLFiRYvXvvDCC9hstiZHUFAnv8F7x4tA15zaeySbzWwdcYbD3pXw9fNWVyQiIt1Iq8PIokWLyMzMZPbs2axatYrU1FQmTpxIfn5+i6+JiIjgwIEDvmP37t2nVHS7q2scRjp5cGorkUmQMds8//B+KN5nbT0iItJttDqMPProo0yfPp1p06YxfPhw5s2bR0hICAsWLGjxNTabjYSEBN8RHx9/SkW3O18YsYE9wNJSOtTY26H3eKgphXd/DoZhdUUiItINtCqM1NTUkJ2dTUZGRsMb2O1kZGSwfPnyFl9XVlZG3759SU5O5uqrr2bDhg3H/Jzq6mpKSkqaHB2q8bRem61jP9tKdjtc+TjYA2HLu7Dpv1ZXJCIi3UCrwkhhYSFut/uolo34+Hhyc5tfUnzIkCEsWLCA//znP7z88st4PB7OPPNM9u7d2+LnzJkzh8jISN+RnJzcmjJPXXeZ1tuc+OFw9k/N83d/CZVFVlYjIiLdQLvPpklPT2fKlCmMHj2a8847jzfeeIOePXvyzDPPtPiamTNnUlxc7Dv27NnT3mU21V2m9bbknJ9Dj4HmRnof/t7qakREpItrVRiJjY3F4XCQl5fX5Pm8vDwSEhJO6D0CAwM5/fTT2bZtW4vXuFwuIiIimhwdyt3F96U5nsAgs7sGIPsfsLvlLjgREZFT1aow4nQ6SUtLIysry/ecx+MhKyuL9PT0E3oPt9vNunXrSExMbF2lHcnXTdMNpvW2JOVsGDPFPH/7J01nGImIiLShVnfTZGZmMn/+fF588UU2bdrEXXfdRXl5OdOmTQNgypQpzJw503f9H/7wBz744AN27NjBqlWruOWWW9i9ezc/+MEP2u5P0da6ezeN18V/gNA4KPwWPnvU6mpERKSLavW81cmTJ1NQUMCsWbPIzc1l9OjRLF682DeoNScnB7u9IeMcPnyY6dOnk5ubS3R0NGlpaXzxxRcMHz687f4Uba07D2BtLDgaLvsLvD7N3Ldm0CXQO83qqkREpIuxGUbnX0yipKSEyMhIiouLO2b8yMb/wL+mQJ90uG1x+39eZ2YY8Nr3YeNbEN0PfvgZuMKtrkpERPzAid6/tTdNc+pqzMfu3jIC5jorVz4OkclweCe883OrKxIRkS5GYaQ5dVXmY3cfM+IVHAXXPQc2O6xdCGv/ZXVFIiLShSiMNMet2TRH6XMGnPcr8/x/mXBop7X1iIhIl6Ew0py6br7OSEvO+bk5jqamFP59O7hrra5IRES6AIWR5mhqb/McAXDtfAiKhH3Z8PGfra5IRES6AIWR5rg1gLVFUclw5RPm+bK/wY6l1tYjIiJ+T2GkOd4BrAojzTttUv3qrAa8eSeUH7S6IhER8WMKI83xTu11aABriy59EGIHQ+kB+O/d5nokIiIiJ0FhpDm+lhENYG2RMxSue94MbFvehZXPWV2RiIj4KYWR5mhq74lJHAUZ95vnH/wW8jZaW4+IiPglhZHmaGrviTvjLhh4sdma9PptUFNudUUiIuJnFEaa45vaq5aR47LZYNLT5u6+BZvgrbs0fkRERFpFYaQ5vqm9ahk5IWE94bv/BHugucngpw9ZXZGIiPgRhZHmaGpv6/VNhyseMc8/fgA2/c/aekRExG8ojDRHU3tPTtpUGH+Hef7mnZC3wdp6RETELyiMNEdTe0/exD9Dv3OhpgxevUkLoomIyHEpjDTHN2ZELSOt5giEG16E6BQo2g2vTdWGeiIickwKI83R1N5TExIDN74KzjDY9Rm8/2urKxIRkU5MYaQ52rX31MUPh2ufNc9XPAvZL1hajoiIdF4KI83RCqxtY+gVcMFvzfN3fg67l1tbj4iIdEoKI83RANa2c+7PYfgk8NTColugaI/VFYmISCejMNIcTe1tOzYbTPo7JIyEikJYeJOWjBcRkSYURo5kGI26adQy0iacoeaA1pBYyF0H/5rSEPhERKTbUxg5kqcODI95rjEjbScqGW5aCIEhsO1Dcw8bj8fqqkREpBNQGDmSdyYNaDZNW0seB999CewBsP51WPwrbaonIiIKI0dpHEa0N03bG5QB1zwD2Mwpv0v/anVFIiJiMYWRI3nHi9gDwO6wtpauauT1cFl9CPnkz7DyOWvrERERSymMHEnTejvGhDvgvPvM83d+DuvfsLYeERGxjMLIkTStt+Ocfx+Mmw4Y8MYdsC3L6opERMQCCiNH8k3r1XiRdmezmd01p13bsCja3q+trkpERDqYwsiR6hRGOpTdbg5oHXAh1FbA/10P+ZutrkpERDqQwsiRtElexwtwmlN+k8ZC5WF46RooyrG6KhER6SAKI0dSy4g1XGFw82sQOwRK98M/roBDO62uSkREOoDCyJE0ZsQ6ITEw5S3oMRCKc+CFK+DgdqurEhGRdqYwcqQ67UtjqYhe8P13oOdQKNkH/7gcCrZYXZWIiLSjkwojc+fOJSUlhaCgICZMmMCKFStO6HULFy7EZrMxadKkk/nYjuEbM6KpvZYJT4Cp/4O406As12whydtodVUiItJOWh1GFi1aRGZmJrNnz2bVqlWkpqYyceJE8vPzj/m6Xbt28fOf/5xzzjnnpIvtEOqm6RzCesL3/wcJo6C8wAwkB76xuioREWkHrQ4jjz76KNOnT2fatGkMHz6cefPmERISwoIFC1p8jdvt5uabb+b++++nf//+p1Rwu9MA1s4jJAam/heS0qDyELx4JezLtroqERFpY60KIzU1NWRnZ5ORkdHwBnY7GRkZLF++vMXX/eEPfyAuLo7bb7/9hD6nurqakpKSJkeH0dTeziU4Gm59C5InQFUx/HMS7DmxbkEREfEPrQojhYWFuN1u4uPjmzwfHx9Pbm5us69ZtmwZzz//PPPnzz/hz5kzZw6RkZG+Izk5uTVlnhp103Q+QRFwyxvQ92yoLjHXIdn1udVViYhIG2nX2TSlpaXceuutzJ8/n9jY2BN+3cyZMykuLvYde/bsaccqj6Bums7Juw5J//OhpsxcqXX7x1ZXJSIibSCgNRfHxsbicDjIy8tr8nxeXh4JCQlHXb99+3Z27drFlVde6XvO4/GYHxwQwJYtWxgwYMBRr3O5XLhcFoUBzabpvJwhcNNCcw+bbR/C/90AV8+F1MlWVyYiIqegVS0jTqeTtLQ0srIadlf1eDxkZWWRnp5+1PVDhw5l3bp1rFmzxndcddVVXHDBBaxZs6Zju19OlNYZ6dwCg+HGVxo213vzDvj0YTAMqysTEZGT1KqWEYDMzEymTp3K2LFjGT9+PI899hjl5eVMmzYNgClTppCUlMScOXMICgpixIgRTV4fFRUFcNTznYbGjHR+AS647nmI7A1fPAEf/RGK98Dlj4Cj1X+lRUTEYq3+l3vy5MkUFBQwa9YscnNzGT16NIsXL/YNas3JycFu9+OFXetqzEeFkc7NbodL/ghRfeC9X0L2C1CyH67/hzm+RERE/IbNMDp/+3ZJSQmRkZEUFxcTERHRvh/22jTY8AZc+hc444ft+1nSNja/A6/fDnWVkJgK33sNwuOP/zoREWlXJ3r/9uMmjHbi9raMaACr3xh6hblaa0isuUrrcxnaz0ZExI8ojByprsp81ABW/9J7LPxgCcQMMHf8ff5irUUiIuInFEaOpKm9/iumP9y+BHqPN1drfWkSrHvd6qpEROQ4FEaOpKm9/i20h7mfzbArzS63f98OS2aBu87qykREpAUKI0fS1F7/FxgMN7wIZ91j/vz54/B/10HFIWvrEhGRZimMHMk7tVfdNP7N7oCL/2BO9Q0MhR2fwDPnmQNcRUSkU1EYOZIGsHYtI66FH3wI0f3qB7ZeAt8stLoqERFpRGHkSCcxtbe0qpb5n+5gc25JOxUlpyR+ONzxMQy6xAybb94J7/0K3LVWVyYiIiiMHK2VLSPFlbXc+vwKHnh3E9f9/QtW7NS4hE4pOBpuWgTn/tL8+at58M+roSzf2rpERERh5CitGDNSVFHDLc99xZo9RQCU17iZumAFX2wvbMcC5aTZ7XDhb2Dy/4EzHHZ/bo4j2ZttdWUiIt2awsiR3Cc2tfdQeQ3fm/8V6/YVExPq5K0ZZ3Hu4J5U1rq57YWVfLa1oAOKlZMy7Dsw/SOIHQyl+2HBRPjiKfB4rK5MRKRbUhhpzONpNGak5am9hWXV3PTsl2w8UEJsmIuFd5zB6OQonr01jQuHxlFV6+H2F7/m4y3qAui0eg6GH2SZ65F4auGD38ArN6jbRkTEAgojjXmDCLTYTZNfUsWNz37JlrxS4sLNIDI4PhyAoEAH825J4+Lh8dTUebjzn9l8uDGvIyqXkxEUAd99Ca541GwJ2/YhPH2m+SgiIh1GYaQx7+BVaLabJrfYDCLb8stIjAxi0Z3pDIxrul29M8DO328ew+UjE6hxe/jhy9ksXp/b3pXLybLZYNztcMcnEHcalBfAy9fB+79pWI1XRETalcJIY01aRgKb/GpfUSWTn13OjsJykqKCWXRHOv1iQ5t9m0CHnSduPJ0rU3tR5zGY8coq/rd2f3tWLqcqbhhMz4Lxd5g/L3/K3P23cKu1dYmIdAMKI4013pfGZvM9vedQBZOfWc7ugxUkxwSz6M4z6NMj5JhvFeCw87fvpnLt6Um4PQY/eXU1/1mzrz2rl1MVGAyXPwQ3vgrBMZC7Fp45F1b9EwzD6upERLoshZHGfDv2Ngxe3VdUyeRnlrP3cCUpPUL4153p9I4+dhDxCnDYeeiGVG5I643HgJ8uWsO/s/e2R+XSloZeDnd9Dv3OhdoK+O+P4fVp2ttGRKSdKIw05pvW2zB49cUvdrG/uIr+PUNZdGc6iZHBrXpLh93GX64bxU3j+2AY8Kt/r2X59oNtWbW0h4hecOtbcNFssAfAhjdh7gTY9LbVlYmIdDkKI401s/pqQakZUCaPTSY+4uT2q7HbbTwwaQRXj24YQ7LnUMUplyvtzO6AczLhtg8gdgiU58OiW+C1aVCuhe1ERNqKwkhjzay+Wlpl7l8SHhTY3CtOmL2+hWREUgSHymu446VsKmrqTuk9pYP0ToM7P4WzfwY2B2x4w2wl2fCm1ZWJiHQJCiONNdMyUlJlBobwoIBTfvugQAfP3jqW2DAnmw6U8IvX1mJoYKR/CAyCjN+bOwDHDYeKQnjt+7DoVi2UJiJyihRGGmtmx96yNgwjAL2ignn6ljQCHTbeWXeAv3+yvU3eVzpI0hhzTZJzf2mOJdn0X7OVZO1rmnEjInKSFEYaa2Y2TWl123TTNDYuJYY/XD0CgIc/2KJVWv1NgMvccG/6RxA/EioPwRs/gIXfgxKtJyMi0loKI4351hlpFEbauGXE66bxfbj1jL4Y9VN+t+WXtun7SwdITIU7Pobzfw32QNjyLjw1ztx0z11rdXUiIn5DYaQxd9MwYhhGu4URgFlXDmd8vxjKquuY/s9siit0A/M7jkA4/1dw51LoPQ5qysxN9545F3Z/YXV1IiJ+QWGkMd8AVjOMVNa6cXvMcQBt2U3jFeiw8/TNY0iKCmZnYTk/Xrja93niZ+JPM6cAX/WkuXpr/kb4x2Xw5l1QVmB1dSIinZrCSGO+qb1mGPEOXrXbINTpaJeP7BHm4tkpaQQF2vn02wL+unhzu3yOdAC7HcZMgR9nw5ip5nPfvAJPpcGK+eBxW1ufiEgnpTDS2BHdNN5pvWGuAGyN9qppa6f1iuThG1IBeObTHby1WnvY+LWQGLjqCbj9Q0gYBVXF8O7PYf6FsC/b6upERDodhZHGjhjA2lYLnp2I74zqxYwLBgDwy3+vJXv34Xb/TGlnyePMacCXPQSuSDiwBuZfZO51U6oZVCIiXgojjR0xtbc9B682596Lh5AxLJ6aOg93/PNrcg5qyXi/Z3fAhDvgx1/DqBsBw9wF+InTYelfoUb/G4uIKIw0dlTLSMeGEbvdxuM3jmZEUgQHy2v4/gsrKKqo6ZDPlnYWFgfXPgO3vQ9JY6G2HD5+AJ5MgzWvgMdjdYUiIpZRGGnsiDEjZe2w4NnxhLoCWDB1HL0ig9hRUM6dL2VTU6cbVZfR5wxzSfnrnofIPlC6H966C549D3Z+anV1IiKWUBhpzOKWEa+4iCAWTBtHmCuAr3Ye4r5/aw+bLsVmg5HXw90rIeN+cEVA7lp48Up45UYo3Gp1hSIiHUphpLEjxoy05SZ5rTU0IYK/3zwGh93GG6v38XiWblBdTmAQnP1T+MlqGDfd3BH42/fMvW7+lwklB6yuUESkQyiMNOZufjZNmKvjumkaO3dwT/40ydzD5rEPt/LGqr2W1CHtLDQWrngYfvQlDL4MDDd8/Tw8MRre/w2UF1pdoYhIuzqpMDJ37lxSUlIICgpiwoQJrFixosVr33jjDcaOHUtUVBShoaGMHj2al1566aQLbledpJumsZvG9+GH55lTfn/177V8ueOgZbVIO+s5GL63EKb+D5InmCsCL38KHk+Fj/4ElUVWVygi0i5aHUYWLVpEZmYms2fPZtWqVaSmpjJx4kTy8/ObvT4mJobf/OY3LF++nLVr1zJt2jSmTZvG+++/f8rFt7mjpvaaLSMRFoYRgF9OHMIVoxKpdRvc+VI22wvKLK1H2lm/c8xZNze/bm7GV1MGnz4Ej4+CTx+Gav3vLyJdS6vDyKOPPsr06dOZNm0aw4cPZ968eYSEhLBgwYJmrz///PO55pprGDZsGAMGDOCee+5h1KhRLFu27JSLb3Pu+mm0vtk03pYRa7ppvOx2G4/ckMqYPlEUV9Yy7R8rOVhWbWlN0s5sNhh0MdyxFCa/DD2HmSu5fvRHs6Vk+VyorbS6ShGRNtGqMFJTU0N2djYZGRkNb2C3k5GRwfLly4/7esMwyMrKYsuWLZx77rktXlddXU1JSUmTo0McsVFeZ+im8QoKdDB/ylj6xISQc6iCH/zzayprtNdJl2ezwbAr4a7P4drnIKY/VBTC+7+Gx0fDF09BTbnVVYqInJJWhZHCwkLcbjfx8fFNno+Pjyc3N7fF1xUXFxMWFobT6eSKK67gySef5OKLL27x+jlz5hAZGek7kpOTW1PmyfNtlOcEGocRa1tGvHqEufjHtHFEBgeyOqeIO176mqpaBZJuwe6AUTfAjJVw1VMQmQxlufDBb+BvI8zVXDWmRET8VIfMpgkPD2fNmjWsXLmSBx54gMzMTD755JMWr585cybFxcW+Y8+ePR1RZqOWkSCg8Wwa61tGvAb0DGPB98cS4nTw2dZCZvzfKi2K1p04AmDMrfDjVXDVk2ZLSeUhczXXv42AD38PZQVWVyki0iqtCiOxsbE4HA7y8ppu8pWXl0dCQkLLH2K3M3DgQEaPHs29997L9ddfz5w5c1q83uVyERER0eToEC3s2tsZumkaS+sbw/NTx+EKsJO1OZ+fvLqaWrcCSbcS4IQxU8yWkuueh7jhUFMKy/4Gj42Ad38JxZoKLiL+oVVhxOl0kpaWRlZWlu85j8dDVlYW6enpJ/w+Ho+H6upOOACz0dTe6jq3r8UhopN00zSWPqAH86eMxemws3hDLpn/+ga3R6u0djuOAHM11x9+Dje+CklpZgvfimfMMSX/uRsKtlhdpYjIMbW6myYzM5P58+fz4osvsmnTJu666y7Ky8uZNm0aAFOmTGHmzJm+6+fMmcOSJUvYsWMHmzZt4pFHHuGll17illtuabs/RVtpNLW3rL5VBCCsk7WMeJ07uCfzbh1DoMPG29/s5xevf4NHgaR7stth6OXwgyyY8h9IOQc8tbD6JZg7Hv7vBtjxCWhbARHphFp9l508eTIFBQXMmjWL3NxcRo8ezeLFi32DWnNycrDbGzJOeXk5P/rRj9i7dy/BwcEMHTqUl19+mcmTJ7fdn6Kt+Kb2On2DV0OdDhx2m4VFHduFQ+N58qYxzHhlFW+s2ofTYefP14zE3olrlnZks0H/880j5yv44gnY/A5s/cA84kdA+gwYcb3Z1SMi0gnYDD/Yga2kpITIyEiKi4vbd/zI/dFgeODeLawrDubKp5YRH+Hiq19nHP+1Fnv7m/3cs3A1HgOmpPfl/qtOw2ZTIBHg4Hb4ah6sfhlqK8znwhJg/HQYexuExFhbn4h0WSd6/9beNF7uOjOIADicvpk0nWVa7/FcmdqLh29IxWaDfy7fzQPvbNJOv2LqMQAufwgyN0LG7yE80ZwW/NEf4W+nwTv3alyJiFhKYcTLO60XICCo086kOZZrx/TmwWtHAvDcsp089P4WBRJpEBwNZ/8M7lkL1zwLCSPNlpKVz5njSl68Ejb+1wzmIiIdyH/utO3NO14EIMDVaZaCb63J4/pQU+fhd//ZwN8/2Y7bY3DfZUPVZSMNApyQOhlGfRd2LYMvn4Zv34Odn5pHeC8YO82cOhze8pR9EZG2opYRL+9MGpsD7I5G3TT+l9duTU9h1neGA/DMpzu497VvtA6JHM1mMzflu+kVs7XknHshJBZK99cvonYavDYNdn2uWTgi0q4URryOWn3VbBmxesfek3Xb2f146PpROOw23li1j9tf/JryajW/SwuikuGiWea4kmufg+QJ4KmDDW/AC5fD02fCivlQedjqSkWkC1IY8Wo0rRc651LwrXXD2GSemzqW4EAHn35bwPfmf6ndfuXYAlzmHji3fwB3fgZjpkJgCORvhHd/Do8MhTfugJ2fqbVERNqMwohXCy0j/jZm5EgXDInjlekTiA4J5Ju9xVz39BfkHKywuizxB4mj4KonIHMTXPoXiDvN/O9k7SJ48Tvw5Bj47FEobXmTTBGRE6Ew4nXkjr3V/jebpiWn94nm9bvOpHd0MLsOVnDt01+wfl+x1WWJvwiOgjN+CHd9DtM/grTvgzMMDu2ArPvh0eHw6k2w5T3NxBGRk6Iw4uXbJK9rtYx4DegZxht3ncmwxAgKy6q58dkvWba10OqyxJ/YbObeN1c+DvdugavnQvIZYLhhy7vw6o3wt+Hw/m8gd53V1YqIH1EY8fJ10zQdM9IVWka84iKCWHTnGaT370FZdR3TXljBf7/Zb3VZ4o9cYXD6LXD7+zBjBaTfDSE9oCwPlj8F886Gv58Jnz8OJQesrlZEOjmFES9fN40LaNwy0nXCCJg7EL9w2ziuGJVIrdvgJ6+uZt7S7VocTU5ezyEw8QHI3GzuHDz8arO7M38DLJlltpb8cxJ8swhqyq2uVkQ6oa51pz0VRw1grW8ZcXWNbprGXAEOnrzxdHqGuXjhi108+N5m1u0t5i/Xj/Lr2UNisQCnuXPw0MvNKcAb3jIHu+Yshx0fm8f/QmHYd8yN+gZcAI6u99+XiLSe7jxeR03t7ZotI152u43ZVw5nQM9Q/vC/jbyz7gDf5pXyzK1p9O8ZZnV54u+Co81VXMdOg0M7Ye2/4JtX4fBOM6CsXWReM+wqGHEdpJwNdofVVYuIRdRN41XXMIDV7TGoqHEDXTeMANhsNm5NT2HhHWcQF+5ia34ZVz/1OR9s0FRNaUMx/eD8X8FPVsPtS2D8nRAaZ7aerHoR/nmVuX7Ju7+EnC/Bo9WCRbobhREvbxhxOCmrapie2FVm0xxLWt8Y/veTsxmfEkNpdR13vJTNIx9swe3ROBJpQzYbJI+Hy/8K926GKf81F1ULioLyfFjxDCyYCI+NNGfk7FmpYCLSTSiMePmm9rooqR8v4gqw4wzoHl9RXHgQ/zd9AtPOSgHgyY+2Me2FlRRV1Bz7hSInw+6A/ueZi6r9fCt87zUYdSM4w6Fkrzkj5/kMc3+cd39pbujncVtdtYi0k+5xpz0RvgGsri4/XqQlgQ47s688jcdvHE1QoJ1Pvy3gyqeWsWG/FkiTdhTghMGXwLXPwC+2wndfMseROMPMTftWPAMvXAGPDIG374FtWeCutbpqEWlD3etueyyNpvY2rDHS9btomnP16CQGx4dz50vZ5Byq4Nq/f8GfJo3g+rTe2Gw2q8uTriwwGIZfZR61VeYMnI3/NRdVKy+A7BfMIygShlwOQ6+AAReCM9TqykXkFCiMeDVqGSnrQkvBn6xhiRG8fffZ/HTRaj7eUsAvXl/LR5vzeeCakcSEOq0uT7qDwCAYcpl5uGth12dmMNn8PzOYfPOqeThc0P9887rBl0JEotWVi0grdd+77ZF8U3u7bzfNkSJDAnl+6jieXrqdvy35lvfW57Jy12H+ev1ILhwab3V50p04As0WkAEXwhWPmLNuNr1ttpgU7Yat75sHQK8x9a0ml0PccHPgrIh0at37btuYbzaNq0sveNZadruNGRcM5LzBPfnZojVszS/jthe+5qbxffjtFcMI1SJp0tHsDkg5yzwunQMFm81QsuU92LsS9q8yj4//BFF9zNaSgReba5k4Q6yuXkSaoTuJV13j2TRqGTnSiKRI3v7x2Tz0/haeX7aTV1fk8MX2Qh79bippfWOsLk+6K5sN4oaZxzn3QmkefLvYDCY7PoaiHFjxrHkEBEHKOTDoEhh0sbn+iYh0CrrbejWa2ltaaoaRMIWRJoICHfzuO8O5aFgcP//XN+w+WMEN85bzw/MG8NOMwd1mGrR0YuHxkDbVPGoqYMcnsPUD2LrEnDK8bYl5vAf0GNgQTPqeBQEuq6sX6bZ0t/Vq1DJSVt29Z9Mcz5kDYln8s3P5/X838Maqffz9k+18sqWAv00ezZCEcKvLEzE5Qxr2yjEMszvHG0xylsPBbebx5d8hINjsxvGOS+k5RGNNRDqQwohXkzEjZstIhFpGWhQRFMij3x3NxcPi+fWb69h4oIQrn1zGnef1Z8YFAwkK1D4j0ok07s456x6oKm7UavIhlOU2tJoAhPeqDyYXQP8LILSHpeWLdHW623o17qbRmJETdtnIRNJSopn573Vkbc7nyY+28daaffzhqhFcMDTO6vJEmhcUCcOvNg/DgPyNsP0j89j9hbnY2pqXzQMbJKaawaTfuZB8hgbCirQx3W296hqHEXXTtEZceBDPTR3L+xtyuf/tjew5VMm0F1Yy8bR4Zl95Gr2igq0uUaRlNhvEn2YeZ/4YaivNbpztH8H2jyFvPRxYYx7L/gYOJ/Qeby5n3+9cSEozpx6LyElTGPFqppsmTNNWT5jNZuPSEYmcM6gnT2Rt5fllO3l/Qx6fbS3knosGcdvZ/Qh0aICr+IHA4IaxI2DO0NnxMexYCjuXQsk+2L3MPD5+AAJDoe+ZZjDpdy4kjDSnH4vICdPd1qtO3TRtIdQVwMzLh3HtmN789q11rNx1mDnvbebfq/byp0kjGd9P04DFz4THQ+qN5mEYcGiHGUp2LDVXha042HS8iSsS+pxhroPS92yzi8ehf0tEjkX/hXg1GTNibgynbpqTNyQhnEV3pPPvVXuZ895mvs0r47vPLOe6Mb355aVDiI8IsrpEkdaz2aDHAPMYext4PJC/AXZ+ah67Pofq4qYrwjrDIHlCQzjpdbq5OaCI+CiMeNVvlGc4Gvam0WyaU2O327hhbDIZw+L56/tbeHVFDv9etZd31u3nB2f3587z+ivwiX+z281umYSRkD4D3HWQuxZ2f24Gk5wvzJk727PMAyAwBHqPhT7pZgtK73Hg0pR46d5shmEYVhdxPCUlJURGRlJcXExERET7fMhfB0BFIRU/WMbwp3IA2PSHSwl2qu+3razKOcyf/reRVTlFAMSEOvnJhQP53oS+WjBNuiaPG/I21IeTZeZMncpDTa+x1Qea5DPMcNInXZv9SZdxovdvhRGvOclQXUL+979g/LxdBNhtbH3gMmxa+KhNGYbB+xvy+OvizewoLAegb48QfjFxCFeMTNT3LV2bx2MuvrbnS3Ozv5zl5pL1R4rqa3btJI83W07iR2jcifglhZHW+mNPcNew49YVXDh/G1EhgayZdUn7fJZQ6/awaOUeHvtwK4Vl5nid1N6R3HfZMNIHaIEp6UaK9zUKJ1+aU4kNT9NrAkPMKcS9x9UHlPFaiE38wonevxW1wRwh7zbHjJTWmt0FmknTvgIddm45oy/XnJ7E/M928OynO/hmbzE3zf+SC4fGkXnxYEYkRVpdpkj7i0yCyOtgxHXmz1UlsHcF7FlpPu7NNgfF7vrMPLxi+pvhJGks9E4zW0+0v474qZO6486dO5eHHnqI3NxcUlNTefLJJxk/fnyz186fP59//vOfrF+/HoC0tDT+/Oc/t3i9JbzTeoGSuvow4tLAyo4Q6grgpxmDuXlCX57I2sqrK3L4aHM+H23O58Khcfz4woGc3ifa6jJFOk5QBAzMMA8wu3YKt8CeFQ0hpXCLOcX40A5Yu8i8zuGEhFH1LShjzceY/tpjR/xCq8PIokWLyMzMZN68eUyYMIHHHnuMiRMnsmXLFuLijl7++5NPPuGmm27izDPPJCgoiL/85S9ccsklbNiwgaSkpDb5Q5wyd6MwUmMOWFXLSMfqGe7ij5NGMO2sFB7P2srb3+z3hZKzB8by4wsHMqG/mqWlG7LbG/bVSZtqPldxCPZlm8fer83HykOw72vzWPGMeV1QlBlKep3ecET0UkCRTqfVY0YmTJjAuHHjeOqppwDweDwkJyfz4x//mPvuu++4r3e73URHR/PUU08xZcqUE/rMdh8zUlYADw8E4JVL1/Lrt9aTMSye56aObfvPkhOys7Ccv3+8jTdX76POY/4VHd8vhp9cOIizBvbQQFeRxgwDDu+EfasawsmBb5r8Hy2fsPim4aTX6RCmfaSkfbTLmJGamhqys7OZOXOm7zm73U5GRgbLly8/ofeoqKigtraWmJiWV+Ksrq6murpRa0VJSWvKbL26KvPR4aJUa4x0Cv1iQ3nohlR+ctEg5i3dzmtf72XFzkPc8vxXjE6O4icXDeSCIXEKJSJgtnTE9DePkdebz9XVmINh969uOPI3QVkefLvYPLwiksyVYhNTza6exFS1oEiHatUdt7CwELfbTXx8fJPn4+Pj2bx58wm9x69+9St69epFRkZGi9fMmTOH+++/vzWlnZr6wauNl4IPUxjpFJJjQnjgmpHcfeFAnv10B698lcOaPUXc9sLXDIkP57azU7h6dBJBgVoPRqSJACckjTEPr5qKowNKwRZzv52SfbDl3YZrQ2IhcVTTkBLdz+w2EmljHXrHffDBB1m4cCGffPIJQUEtLwc+c+ZMMjMzfT+XlJSQnJzcfoV5W0YCGlZf1ZiRziUxMpjZV57Gj84fyHPLdvDS8t1sySvlV/9ex18Xb+HmCX245Yy+xGmZeZGWOUPMqcHJjSYQVJdC7jo4sNbs2jnwjbkWSkVh/c7FHzV6fbi5u3HCSEgYYT7GDTc3FxQ5Ba2648bGxuJwOMjLy2vyfF5eHgkJCcd87cMPP8yDDz7Ihx9+yKhRo455rcvlwuXqwClqjXbsLamqBbQvTWfVM9zFzMuG8aPzB7JoZQ4vfrGbfUWVPPHRNp5eup0rU3tx21n9NC1Y5ES5ws1dh/ue2fBcbSXkb2wIJwfWmivJ1pSaa6Ls+bLhWpsdegxqCCjxI83AEp6gbh45Ya0KI06nk7S0NLKyspg0aRJgDmDNysri7rvvbvF1f/3rX3nggQd4//33GTu2Ew4K9XXTOLVjr5+IDA7kjnMHcNtZ/fhgYx4Llu3k692HeWPVPt5YtY/x/WK4/ex+ZAyLx2HXP4girRIYbM7CSUpreM5dBwe3mq0ouWshd735WHHQnGpcuAXWv95wfXC0ufZJ/GnmEXcaxA0FZ2jH/3mk02v1HTczM5OpU6cyduxYxo8fz2OPPUZ5eTnTpk0DYMqUKSQlJTFnzhwA/vKXvzBr1ixeeeUVUlJSyM3NBSAsLIywsLA2/KOcAl83TRClahnxKwEOO5ePTOTykYms2VPEPz7fyTtrD7Bi5yFW7DxEUlQwN45L5oaxySREqgtH5KQ5AhqmGI/6rvmcYUBprjkOJXetGVTyNpqhpfLw0Qu1YYOYfmY46Vn/XnHDzV2QHfo3tztrdRiZPHkyBQUFzJo1i9zcXEaPHs3ixYt9g1pzcnKwNxrg9PTTT1NTU8P111/f5H1mz57N73//+1Orvq3U79iLo1HLiEstI/5mdHIUj994OvddNpSXlu/mlRU57Cuq5JEl3/K3D7/lwqHxfG9CMucNjlNriUhbsNnMTf0iEmHQxQ3P11aaA2PzN5rdO3nrzZBSnt+wWNumtxuutwdC7OD6cDLUDCg9h0J0Ctg1OL070N40ABv/C/+6FZLP4LxD97H7YAWv/zCdsSktTz+Wzq+q1s176w/w6ld7WLGrYafUxMggvjs2me+OSyYpSgPvRDpMWYEZTAo2m0Elf5N51JQ1f31AEMQOMoNJzyH1j0PNWT3aONAvaG+a1mh2zIiaDP1dUKCDa07vzTWn92ZbfikLV+zh36v2cqC4iseztvLER1s5f3BPJo/rw4VD43AGaMqiSLsK6wlhF8CACxqeMwwo3lMfTDY2PBZuNbvQc9eZR2P2QDOkxA42Q0rsYPPoMdCcMSR+R2EEfLNpDIer0ZgRfTVdycC4cH77neH84tIhvL8hj1e/ymH5joN8vKWAj7cUEBUSyHdGJXLN6UmM6ROtxdREOorNBlF9zGPwxIbnPW4o2m129xRsbvpYW1EfXDYe+WYQlVwfToY0BJbYQRDaU7N7OjHdccE3gNXjcFHrNnutFEa6JleAg6tSe3FVai92FpazcGUOb67aR35pNS9/mcPLX+bQJyaESacncc3pSfSL1ch/EUvYHQ2ryg65rOF5jwdK9taPSdkEhd+arSiFW8xBs0U55rHtw6bvFxRptpz0GASx3sdB5vtrnRTLacwIwJdPw+L7qBoyiaHffBebDbY/cDl2DXLsFtwegy+2F/Lm6n0sXp9LRY3b97vRyVFcOyaJ74zqRUyo08IqReS4ygvNcFKwpT6gfGuGlKI9QEu3OhtEJpszenoMNB9jBpiPUX01NuUUacxIa9S3jNTazJtNmDNAQaQbcdhtnDOoJ+cM6smfJtWxZGMeb6zax2dbC1izp4g1e4r4w9sbSR/QgytGJnLJaQkKJiKdUWiseTRewA3M2T2HdpgB5eA28yjcak5BriqG4hzz2PFx09fZA8wZPd5wEtO/4TGit4JKG9I3Cb6pvdWYg1bVRdN9hTgDuHp0ElePTiK/tIq3vznAm6v3sn5fCZ9tLeSzrYX85q31pPfvwWUjE5h4WgKxYR24WrCItF5gcMPia40ZhtmacnArHNwOh7bXh5Ud5nldVUN42XrEe9oDIbpvQ1dS4yMy2dwbSE6Y7rrg22a72vCGEc2kEYgLD+L2s/tx+9n92FlYzrvrDvDuugNs2F/Csm2FLNtWyO/eWs8Z/Xtw2chELj0tgZ7hCiYifsNmq5/h0/Po1hSPB0r3myHl4LaG9VEO7YBDO837hjeoHPW+drPlJCbFnIYcnWIu9uY9D45q/z+bn1EYAd9smmrD/DrUMiJH6hcbyowLBjLjgoHsKiznvfW5vLvuAOv2FfPF9oN8sf0gs/6znrQ+0Vw0LJ6Lh8cxoGeYZuWI+Cu7HSJ7m0f/85r+zhtUvOHk4PaGkHJ4pznbx9v1s/PTo987ONoMJVF9zcfovg0/d9NWFd11wRdGKj0KI3J8KbGh3HX+AO46fwA5Byt4b73ZYvLN3mK+3n2Yr3cf5i+LN5PSI4SLhsWTMSyecSnRBDi0jolIl9A4qPQ7t+nvDAPK8s1Q4g0nh3c1nJcXmLN+Kg/D/tVHv7fNDhFJ9UGlr/nonfoc3RfCE7vkqrS664JvAGtFfctImLpp5AT16RHCnecN4M7zBrC/qJKsTXl8uCmf5dsPsutgBc8v28nzy3YSGRzI+UN6kjEsnnMH9yQyWH/HRLokmw3C482jzxlH/766FA7vNtdQObzLPD+8q/7n3VBXaS4CV7wHdi87+vX2ADME+UJKX3Ntlag+ZqtKeKJfDqz1v4rbQ/0KrJVuM22qZURORq+oYG5NT+HW9BTKqutYtrWAJRvz+WhzHocravnPmv38Z81+HHYbo5OjOG9wT84d3JORSZHaK0eku3CFQ8II8ziSt1WlqFFAKcqpDy85ZkDx1NWHmF3Nv7/NAZFJENnHDCmRyQ2Pkcnm7zrhuiq664KvZaRc3TTSRsJcAVw6IpFLRyTi9hiszjnMkk15ZG3KZ1t+Gdm7D5O9+zCPLvmW6JBAzh7U0wwng2KJi9DuwiLdUuNWleTxR//e44bSA40Cym5zDZXinPrHveCpbVj4bXcLnxMSWx9QetcHlPoup75nQ2iPdv0jtkR3XfBN7S2vM1tGItRNI23IYbcxNiWGsSkxzLxsGPuKKvn02wKWbing822FHK6o5e1v9vP2N/sBGJYYwTmDYjlzQA/GpcQQqh2kRQTMsSK+4HDm0b/3eKAstz6Y7GkUVvbW/7wHasuhotA8jhyz8v13IPTsjvmzHEH/yoFvam9pnTnAUC0j0p6SooK5aXwfbhrfh1q3hzV7isxw8m0B6/YVs+lACZsOlPDspzsIqO/SOXNAD9IHxHJ6nyiCArve4DURaQN2O0T0Mg8mHP17w4CqIjOcNA4pxfXnUX07umIf3XXBN5umtE7dNNKxAh12xqXEMC4lhnsvGcLBsmqWbSvk822FfL7tIPuKKn0zdJ74aBuuADtjU6I5c0As6QN6MKJXpHYbFpETY7OZ04qDoyFhpNXVNKG7LjQKI+Y/6mEuddOINXqEuXwrwALsOVTBF9sLfWuZFJRW8/m2g3y+7SAAQYF2xvSJZlxKDOP7xXB6nyhCnPrPWkT8i/7VAl8YKa5VN410LskxIUyO6cPkcX0wDINt+WV8sf0gn28rZOWuQxyuqPUFFYAAu40RSZFM6Ge2toxNiSYqpPstoCQi/kV3XfCNGSmuURiRzstmszEoPpxB8eFMPTMFj8dgW0EZK3YeYuWuQ6zYeYgDxVW+zf2e+XQHAAPjwhjTJ4oxfaIZ0zeagT3DtBGkiHQquuuCr2WkqMb8B1qzacQf2O02BseHMzg+nFvO6IthGOw9XNkQTnYdYkdBOdvyy9iWX8a/vt4LmGF7dHIUaX2jGdMnmtF9ovR3XkQspTACjcaMaNEz8V82m43kmBCSY0K4Lq03AAfLqlmdU8SqnMOsyjnMN3uKKa2q8+1AbL4O+seGkto7ilG9I0lNjmJYYoRm7YhIh9FdFxp27cX8f4dhWtdBuogeYS4yhseTMTwegDq3h825pWY42X2YVTlF5ByqYHtBOdsLynlj9T7AHHsyNDGcUb2jSK0PKAN7hml/HRFpF7rrQsOuvQQSHOjQP7jSZQU47IxIimREUiRT0lMAKCyrZt3eYr7ZW8Q3e4pYu7eYg+U1rN9Xwvp9JbzylflaV4CdYYkRjEiKYEQv8z0GxYfhClALioicGoUR8IWRGiNQXTTS7cSGubhgaBwXDI0DwDAM9hVV8s2eYtbuLeKbvUWs21tMeY3bNzjWK9Bhjlsxw0kEw3tFMCQhQq2LItIq+hfDXQeGG4AaAuihMCLdnM1mo3d0CL2jQ7hiVCIAHo/BroPlrN9fwoZ9xazfX8z6fSUUV9ayYX8JG/aXsOjrhvfo2yOEoQnhDEuMMI+ECHpHB2sWj4g0S3fe+vEiYHbThGtWgchR7HYb/XuG0b9nGFel9gLwzd4xw0ixbyn7vJJqdh+sYPfBCt7fkOd7jzBXAEMTwhmaGM6Q+llAQxLCtQ6KiCiMeLtoAGpQN43IiWo8e+fSEQm+5w+V1/j219l0oJRNB0rYll9GWXWdb2n7xuLCXQxJqA8n8eEMTghnUFyYNggU6Ub0X3t9GPHYHLhxKIyInKKYUCdnDYzlrIGxvudq3R62F5Sx6UAJW3LL+DavlC25pewrqiS/tJr80mrfVGOvpKhgBsSFMSgujIGNHtWSItL16M5b303jtpndM+Hal0akzQU67AxNiGBoQkST50uratmaX8a3uaV8m1cfUvJKKSitZl9RJfuKKvn024Imr4kNczEwLpSBcWEMqO866h8bSlKUxqSI+CuFkfqWkTqb+f+21DIi0nHCgwLNZer7RDd5/nB5DdsKzJVjt+aVmed5pewvrqKwrJrCsmq+3HGoyWtcAXb6xYbSv2co/WPDzMeeYfSLDSUyWP8nQ6Qz0523PozUeltGNIBVxHLRoU7GhZqb/TVWVl3H9vrl7bcVlLGjoIwdBeXsOlhOdZ25oNvm3NKj3i8m1ElKjxBSYkPp1yPUfIw1HzUNWcR6+q/QXQOYg1dBLSMinVmYK4DU5ChSk6OaPF/n9rD3cCU7Cs1wsr2g3AwqheUUlFZzqLyGQ+U1rMopOuo9Y8NcpPQIoU+PEPrGhNK3/rxPTAg9Qp3YbOr6EWlvuvPWVQEKIyL+LMBhJ6W+pePCoU1/V1Zdx65Cs/VkV2E5OwsrfOcHy2t83T5HzvIBM/wkx4TQNyaEvj1C6B0TQnJ0MMkxISRFBWv/HpE2ojtvXdN9aRRGRLqWMFeAbwn8I5VU1bKrsJzdByvIOVTB7oMN5weKqyirrvNNU25OQkQQyTHBJEc3BBVzwbhgEiKDCNTWEiInRHfe+jBSZZhfhcaMiHQfEUGBjOodxajeUUf9rqrWzd7DFb4F3HIOVbD3cAV7DlWy53AFFTVuckuqyC2pYuWuo1tV7DZIjAwmKSqY3tHBJEXXP0aFkBQdTGJkkFpWROqdVBiZO3cuDz30ELm5uaSmpvLkk08yfvz4Zq/dsGEDs2bNIjs7m927d/O3v/2Nn/70p6dSc9uqn9pb5fGGEeUzEYGgQAcD48IZGBd+1O8Mw+BQeQ17Dley51DToOKdklxT5/Gdr9jV/GfEhjnpFRVMr8hg8zEqiKQo8zwxKojYUJemK0u30Oo776JFi8jMzGTevHlMmDCBxx57jIkTJ7Jlyxbi4uKOur6iooL+/ftzww038LOf/axNim5TdeYA1kqPWkZE5MTYbDZ6hLnoEeZi9BGDacHcy6ewrJq9RZXsPVzJ3sMV7DvccL6/qIrKWjeFZTUUltWwdm9xs58T6LARHxFEYmQQiZHB9Y9BJDQ67xHmwqHAIn6u1WHk0UcfZfr06UybNg2AefPm8c4777BgwQLuu+++o64fN24c48aNA2j295arH8BarpYREWkjdruNuIgg4iKCjlpDBcyWleLKWvYVVbK/qIr9RZXsr29F2V//XH5pFbVuoz7AVAJHdwUBBNhtxIW7iK8PJ/ERQSREBJEQ2fAYFx5EsFNdQtJ5terOW1NTQ3Z2NjNnzvQ9Z7fbycjIYPny5W1eXIfwTe01vwqtOSAi7c1msxEV4iQqxMlpvY4eWAvmEvoFpdUcKDbDSW5xFfuLK+sfqzhQVElBWTV1HoP99c+tPsZnRgQFEB9hhpW4CJd5Hu7y/RwXHkTPcJfGsYglWnXnLSwsxO12Ex8f3+T5+Ph4Nm/e3GZFVVdXU13dsIFdSUnzI9nbRH3LSDVOnA67/kMUkU4h0GGvH0cSTFrf5q/xBpbckiryis3BtLmNHvPqB9hW1XooqaqjpKqMrfllx/zciKAAs1Un3GUe9ec964+4cBexYS4igwO1Bou0mU7ZDDBnzhzuv//+jvmw+tk0NUaAumhExK80DiwtMQyDkqo68kuqyCupJr/UfMwrqTrivJqauobQsu04ocXpsBMb5vSFlNiwhkfzcBIb7iI21EVEcICCixxTq+6+sbGxOBwO8vLymjyfl5dHQkJCC69qvZkzZ5KZmen7uaSkhOTk5DZ7/yYarcCqMCIiXY3NZiMyOJDI4EAGxR89M8jLMAxKKuvIL62q30m5ivySagrqd1XOL62ioNT8uaSqjhq3x9c9dDxOh50eYc6GkBLmIibMSWyoix5hTnMwcGj986FOnAFan6W7adXd1+l0kpaWRlZWFpMmTQLA4/GQlZXF3Xff3WZFuVwuXC5Xm73fMfm6aQI1k0ZEui2bzUZkSCCRIccOLWCuwXKwvMYXTnxHWRWFpQ2r2haW1VBWbQaXA8VVHDiB4AJmV1GP+mASE+qkR/1jTKiTHmFOYkJdTZ5T97r/a3VTQGZmJlOnTmXs2LGMHz+exx57jPLyct/smilTppCUlMScOXMAc9Drxo0bfef79u1jzZo1hIWFMXDgwDb8o5ykuoYBrGoZERE5vqBAB0lR5oJux1NV6/YFk8JSM6QcLK/hYFkNB8urOVhW43vuUHkNbo9R31VUx87C8hOqJ8TpIDqkIZzEhDrrfw4kOtRJTP1gYfP5QKJC1PrS2bT67jt58mQKCgqYNWsWubm5jB49msWLF/sGtebk5GC3N/yPvH//fk4//XTfzw8//DAPP/ww5513Hp988smp/wlOlbdlxHBqJo2ISBsLCnTUL5EfctxrPR6DkqpaCstqOFhmbnDoDSne88bPHy6voc5jUFHjpqLGnBp9osJcAUSHBhIdYgaXqJDAox6jQurDS7CTqNBAwl0a+9JeTurue/fdd7fYLXNkwEhJScEwjJP5mI7hbtwyom4aERGr2O0NU54HxoUd93rDMCitruNQWQ2HKsxwcqi8hsMVDWHF/LmWw/W/L6qsxTDMDRTLquvYc+jEA4zDbiMq2OzKigo2w0rDz94AE0hE/RidqPrHiOBA7VN0HGoK8M6m0QBWERG/YrPZiAgKJCIokBRCT+g13tYXX0gpN4NMcX1gKaqspaiihsPl5s/FleZjVa0Ht8cwW2fKa1pda6jTQVSIsz6oBPgGFUc2CiyNHyODzT9XRHAAroCuPyZGd99GA1h7KIyIiHRpjVtfWqOq1k1RRS1FlTXmY0Utxd7zyqY/F1fWHxW1lFbXAVBe46a8lV1JXkGB9vpgEkhEUED9oxlUIoLMyRcN541+X3/uCrB3+u4l3X3VTSMiIscRFOggIdJBQmRQq15X5/ZQWlVHUWWjkFJ/lDQKLcWVtZRUNf19aZUZZKpqPVTVmlOsT0agw0a4N6jUP5pHoO8xIiiAK0Ylkhh5/EHJ7UFhpNEAVnXTiIhIWwpw2IkOdRId2rqWGAC3x6Csuo6SRkGlpLKOkiozyJjPmz+XVtX5fi6t/31pdR2GAbVuwzcI+FhO7xOlMGKZ+qm91QQQpjAiIiKdhMPesGDdyfB4DMpq6iitDyiNH0uaeS4+onWtPm1Jd18teiYiIl2Q3d4wwBesafE4UZprpOXgRURELKUw0mijvAiFERERkQ7X7cOIUR9GqnGqm0ZERMQC3T6MNCx6FqDl4EVERCzQ7cOIUT+Atc7mJMTZ9Ve5ExER6Wy6fRjxDmANcAZ1+hXqREREuqLuHUYMA7vb7KZxBnXuaU8iIiJdVfcOI+6G1eicQcff3lpERETaXvcOI3UN6/wHqWVERETEEgoj9YJcCiMiIiJW6N5hpH68SLURQPhJrv0vIiIip6Z7hxHfGiPal0ZERMQqCiN4N8nTgmciIiJW6N5hxN2w+qpaRkRERKzRvcOIt2XEUMuIiIiIVRRG8I4ZURgRERGxgsII3m4ahRERERErdO8w4p3ai1NjRkRERCzSvcOIt2XEUMuIiIiIVRRG8E7tVcuIiIiIFbp1GKmtqQLMAaxhLrWMiIiIWKFbh5HqqgrzUWFERETEMt06jNRUVwLgsTtx2G0WVyMiItI9KYwAOJzWFiIiItKNdeswUlcfRoyAIIsrERER6b66dRiprTZn09gCXBZXIiIi0n116zDirqnvplEYERERsUz3DiO15tReR6C6aURERKzSrcOIp9bspnE41TIiIiJilZMKI3PnziUlJYWgoCAmTJjAihUrjnn9a6+9xtChQwkKCmLkyJG8++67J1VsWzPqzJaRAGewxZWIiIh0X60OI4sWLSIzM5PZs2ezatUqUlNTmThxIvn5+c1e/8UXX3DTTTdx++23s3r1aiZNmsSkSZNYv379KRd/yupqAAhwqptGRETEKq0OI48++ijTp09n2rRpDB8+nHnz5hESEsKCBQuavf7xxx/n0ksv5Re/+AXDhg3jj3/8I2PGjOGpp5465eJPmVstIyIiIlZrVRipqakhOzubjIyMhjew28nIyGD58uXNvmb58uVNrgeYOHFii9cDVFdXU1JS0uRoDza32TLiDFIYERERsUqrwkhhYSFut5v4+Pgmz8fHx5Obm9vsa3Jzc1t1PcCcOXOIjIz0HcnJya0p84R5w4jLpW4aERERq3TK2TQzZ86kuLjYd+zZs6ddPqdk6A18kTiFHikj2uX9RURE5PhatVVtbGwsDoeDvLy8Js/n5eWRkJDQ7GsSEhJadT2Ay+XC5Wr/6bbjr/95u3+GiIiIHFurWkacTidpaWlkZWX5nvN4PGRlZZGent7sa9LT05tcD7BkyZIWrxcREZHupVUtIwCZmZlMnTqVsWPHMn78eB577DHKy8uZNm0aAFOmTCEpKYk5c+YAcM8993DeeefxyCOPcMUVV7Bw4UK+/vprnn322bb9k4iIiIhfanUYmTx5MgUFBcyaNYvc3FxGjx7N4sWLfYNUc3JysNsbGlzOPPNMXnnlFX7729/y61//mkGDBvHWW28xYoTGaYiIiAjYDMMwrC7ieEpKSoiMjKS4uJiIiAiryxEREZETcKL37045m0ZERES6D4URERERsZTCiIiIiFhKYUREREQspTAiIiIillIYEREREUspjIiIiIilFEZERETEUgojIiIiYqlWLwdvBe8isSUlJRZXIiIiIifKe98+3mLvfhFGSktLAUhOTra4EhEREWmt0tJSIiMjW/y9X+xN4/F42L9/P+Hh4dhstjZ735KSEpKTk9mzZ4/2vOkA+r47lr7vjqXvu2Pp++5YJ/t9G4ZBaWkpvXr1arKJ7pH8omXEbrfTu3fvdnv/iIgI/WXuQPq+O5a+746l77tj6fvuWCfzfR+rRcRLA1hFRETEUgojIiIiYqluHUZcLhezZ8/G5XJZXUq3oO+7Y+n77lj6vjuWvu+O1d7ft18MYBUREZGuq1u3jIiIiIj1FEZERETEUgojIiIiYimFEREREbFUtw4jc+fOJSUlhaCgICZMmMCKFSusLqlL+PTTT7nyyivp1asXNpuNt956q8nvDcNg1qxZJCYmEhwcTEZGBlu3brWm2C5gzpw5jBs3jvDwcOLi4pg0aRJbtmxpck1VVRUzZsygR48ehIWFcd1115GXl2dRxf7t6aefZtSoUb7Fn9LT03nvvfd8v9d33X4efPBBbDYbP/3pT33P6ftuW7///e+x2WxNjqFDh/p+317fd7cNI4sWLSIzM5PZs2ezatUqUlNTmThxIvn5+VaX5vfKy8tJTU1l7ty5zf7+r3/9K0888QTz5s3jq6++IjQ0lIkTJ1JVVdXBlXYNS5cuZcaMGXz55ZcsWbKE2tpaLrnkEsrLy33X/OxnP+Ptt9/mtddeY+nSpezfv59rr73Wwqr9V+/evXnwwQfJzs7m66+/5sILL+Tqq69mw4YNgL7r9rJy5UqeeeYZRo0a1eR5fd9t77TTTuPAgQO+Y9myZb7ftdv3bXRT48ePN2bMmOH72e12G7169TLmzJljYVVdD2C8+eabvp89Ho+RkJBgPPTQQ77nioqKDJfLZbz66qsWVNj15OfnG4CxdOlSwzDM7zcwMNB47bXXfNds2rTJAIzly5dbVWaXEh0dbTz33HP6rttJaWmpMWjQIGPJkiXGeeedZ9xzzz2GYejvdnuYPXu2kZqa2uzv2vP77pYtIzU1NWRnZ5ORkeF7zm63k5GRwfLlyy2srOvbuXMnubm5Tb77yMhIJkyYoO++jRQXFwMQExMDQHZ2NrW1tU2+86FDh9KnTx9956fI7XazcOFCysvLSU9P13fdTmbMmMEVV1zR5HsF/d1uL1u3bqVXr17079+fm2++mZycHKB9v2+/2CivrRUWFuJ2u4mPj2/yfHx8PJs3b7aoqu4hNzcXoNnv3vs7OXkej4ef/vSnnHXWWYwYMQIwv3On00lUVFSTa/Wdn7x169aRnp5OVVUVYWFhvPnmmwwfPpw1a9bou25jCxcuZNWqVaxcufKo3+nvdtubMGECL7zwAkOGDOHAgQPcf//9nHPOOaxfv75dv+9uGUZEuqoZM2awfv36Jn280vaGDBnCmjVrKC4u5vXXX2fq1KksXbrU6rK6nD179nDPPfewZMkSgoKCrC6nW7jssst856NGjWLChAn07duXf/3rXwQHB7fb53bLbprY2FgcDsdRI4Dz8vJISEiwqKruwfv96rtve3fffTf/+9//+Pjjj+ndu7fv+YSEBGpqaigqKmpyvb7zk+d0Ohk4cCBpaWnMmTOH1NRUHn/8cX3XbSw7O5v8/HzGjBlDQEAAAQEBLF26lCeeeIKAgADi4+P1fbezqKgoBg8ezLZt29r173e3DCNOp5O0tDSysrJ8z3k8HrKyskhPT7ewsq6vX79+JCQkNPnuS0pK+Oqrr/TdnyTDMLj77rt58803+eijj+jXr1+T36elpREYGNjkO9+yZQs5OTn6ztuIx+Ohurpa33Ubu+iii1i3bh1r1qzxHWPHjuXmm2/2nev7bl9lZWVs376dxMTE9v37fUrDX/3YwoULDZfLZbzwwgvGxo0bjTvuuMOIiooycnNzrS7N75WWlhqrV682Vq9ebQDGo48+aqxevdrYvXu3YRiG8eCDDxpRUVHGf/7zH2Pt2rXG1VdfbfTr18+orKy0uHL/dNdddxmRkZHGJ598Yhw4cMB3VFRU+K754Q9/aPTp08f46KOPjK+//tpIT0830tPTLazaf913333G0qVLjZ07dxpr16417rvvPsNmsxkffPCBYRj6rttb49k0hqHvu63de++9xieffGLs3LnT+Pzzz42MjAwjNjbWyM/PNwyj/b7vbhtGDMMwnnzySaNPnz6G0+k0xo8fb3z55ZdWl9QlfPzxxwZw1DF16lTDMMzpvb/73e+M+Ph4w+VyGRdddJGxZcsWa4v2Y81914Dxj3/8w3dNZWWl8aMf/ciIjo42QkJCjGuuucY4cOCAdUX7sdtuu83o27ev4XQ6jZ49exoXXXSRL4gYhr7r9nZkGNH33bYmT55sJCYmGk6n00hKSjImT55sbNu2zff79vq+bYZhGKfWtiIiIiJy8rrlmBERERHpPBRGRERExFIKIyIiImIphRERERGxlMKIiIiIWEphRERERCylMCIiIiKWUhgRERERSymMiIiIiKUURkRERMRSCiMiIiJiKYURERERsdT/A5AEehxMSbotAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = [i for i in range(50)]\n", + "y = [np.log(i+1)/(i+1) for i in x]\n", + "y2 = [2*np.log(i+1)/(i+1) for i in x]\n", + "\n", + "plt.plot(x, y)\n", + "plt.plot(x, y2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a9136787", + "metadata": {}, + "outputs": [], + "source": [ + "import sims" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "742861f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'num_sims': 500,\n", + " 'num_agents': 5,\n", + " 'max_range': 1,\n", + " 'step_size': 0.1,\n", + " 'directed': False,\n", + " 'weighted': False,\n", + " 'num_time_steps': 100}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sims.consensus_config\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c460e07", + "metadata": {}, "outputs": [], "source": [] } diff --git a/train.py b/train.py new file mode 100644 index 0000000..0142693 --- /dev/null +++ b/train.py @@ -0,0 +1,19 @@ +from dataclasses import dataclass + +class ModelConfig: + num_agents: int = 10 + embedding_dim: int = 64 + input_dim: int = 1 + output_dim: int = 1 + simulation_type:str = "consensus" + +class TrainConfig: + epochs: float = 100 + learning_rate: float = 1e-3 + verbose: bool = True + log: bool = True + log_epoch_interval: int = 10 + + + + diff --git a/train_and_eval.py b/train_and_eval.py new file mode 100644 index 0000000..8d6854f --- /dev/null +++ b/train_and_eval.py @@ -0,0 +1,259 @@ +import os +import json +import jax +import jax.numpy as jnp +import numpy as np +from dataclasses import dataclass, field, asdict +from enum import Enum +from tqdm import tqdm +from sklearn.metrics import f1_score +import uuid +import pickle +import sys + + +# Import from your existing model file +from model import ModelConfig, TrainConfig, train_model, get_attention_fn + +# Define an Enum for the data source for clarity and type safety + +# Overwrite the original TrainConfig to include our new parameters + +class TrainConfig: + """Configuration for the training process.""" + learning_rate: float = 1e-3 + epochs: int = 100 + batch_size: int = 4096 + verbose: bool = False # Set to True to see epoch loss during training + log: bool = True + log_epoch_interval: int = 10 + + # --- New parameters for this script --- + data_directory:str = "datasets/" + sys.argv[1] + "_dataset" + # Threshold for converting attention scores to a binary graph + f1_threshold: float = -0.4 + + +def prepare_data_for_model(trajectories: np.ndarray, batch_size: int) -> tuple[np.ndarray, np.ndarray]: + """ + Converts simulation trajectories into input-output pairs for the model. + Input: state at time t. Target: state at time t+1. + + Args: + trajectories: A numpy array of shape (num_sims, num_timesteps, num_agents). + batch_size: The desired batch size for training. + + Returns: + A tuple of (batched_inputs, batched_targets). + """ + # For each simulation, create (input, target) pairs + all_inputs = [] + all_targets = [] + + num_sims, num_timesteps, num_agents = trajectories.shape + + # trajectories = np.reshape(trajectories, shape=(num_sims * num_timesteps, num_agents)) + + for i_sim in range(num_sims): + for j_tstep in range(num_timesteps-1): + input = trajectories[i_sim, j_tstep, :] + target = trajectories[i_sim, j_tstep + 1, :] + all_inputs.append(input) + all_targets.append(target) + + all_indices = np.arange(len(all_inputs)) + np.random.shuffle(all_indices) + all_inputs = np.array(all_inputs) + all_targets = np.array(all_targets) + + all_inputs = all_inputs[all_indices] + all_targets = all_targets[all_indices] + + # for sim_idx in range(num_sims): + # # Input is state from t=0 to t=T-2 + # inputs = trajectories[sim_idx, :-1, :] + # # Target is state from t=1 to t=T-1 + # targets = trajectories[sim_idx, 1:, :] + # all_inputs.append(inputs) + # all_targets.append(targets) + + # Concatenate all pairs from all simulations + # Shape -> (num_sims * (num_timesteps - 1), num_agents) + # full_dataset_inputs = np.concatenate(all_inputs, axis=0) + # full_dataset_targets = np.concatenate(all_targets, axis=0) + + # Reshape to have a feature dimension + # Shape -> (total_samples, num_agents, 1) + full_dataset_inputs = np.expand_dims(all_inputs, axis=-1) + full_dataset_targets = np.expand_dims(all_targets, axis=-1) + + # Create batches + num_samples = full_dataset_inputs.shape[0] + num_batches = num_samples // batch_size + + # Truncate to full batches + truncated_inputs = full_dataset_inputs[:num_batches * batch_size] + truncated_targets = full_dataset_targets[:num_batches * batch_size] + + # Reshape into batches + # Shape -> (num_batches, batch_size, num_agents, 1) + batched_inputs = truncated_inputs.reshape(num_batches, batch_size, num_agents, 1) + batched_targets = truncated_targets.reshape(num_batches, batch_size, num_agents, 1) + + return batched_inputs, batched_targets + +def calculate_f1_score( + params: dict, + model_config: ModelConfig, + true_graph: np.ndarray, + threshold: float +) -> float: + """ + Extracts the learned attention graph, thresholds it, and computes the F1 score. + """ + # Get the learned attention matrix (N, N) + learned_graph_scores = np.array(get_attention_fn(params, model_config)) + + # Normalize scores to [0, 1] for consistent thresholding (optional but good practice) + # This uses min-max scaling on the flattened array + # flat_scores = learned_graph_scores.flatten() + # min_s, max_s = flat_scores.min(), flat_scores.max() + # if max_s > min_s: + # learned_graph_scores = (learned_graph_scores - min_s) / (max_s - min_s) + + # Threshold to get a binary predicted graph + predicted_graph = (learned_graph_scores > threshold).astype(int) + + # The diagonal is not part of the prediction task + # np.fill_diagonal(predicted_graph, 0) + # np.fill_diagonal(true_graph, 0) + + # Flatten both graphs to treat this as a binary classification problem + true_flat = true_graph.flatten() + pred_flat = predicted_graph.flatten() + + return f1_score(true_flat, pred_flat) + +def main(): + """Main script to run the training and evaluation pipeline.""" + + train_config = TrainConfig() + + # Check if the data directory exists + if not os.path.isdir(train_config.data_directory): + print(f"Error: Data directory '{train_config.data_directory}' not found.") + print(f"Please run the data generation script for '{train_config.data_directory}' first.") + return + + print(f"šŸš€ Starting training pipeline for '{train_config.data_directory}' data.") + + # Get sorted list of agent directories + agent_dirs = sorted( + [d for d in os.listdir(train_config.data_directory) if d.startswith("agents_")], + key=lambda x: int(x.split('_')[1]) + ) + + for agent_dir_name in agent_dirs: + agent_dir_path = os.path.join(train_config.data_directory, agent_dir_name) + + all_results_for_agent = [] + + graph_files = sorted([f for f in os.listdir(agent_dir_path) if f.endswith(".json")]) + + print(f"\nProcessing {len(graph_files)} graphs for {agent_dir_name}...") + + for graph_file_name in tqdm(graph_files, desc=f"Training on {agent_dir_name}"): + file_path = os.path.join(agent_dir_path, graph_file_name) + + with open(file_path, 'r') as f: + data = json.load(f) + + # 1. Load and Prepare Data + trajectories = np.array(data['trajectories']) + s, l, n = trajectories.shape + # trajectories = trajectories.T + # np.random.shuffle(trajectories) + # trajectories = np.random.shuffle(trajectories) + true_graph = np.array(data['adjacency_matrix']) + inputs, targets = prepare_data_for_model(trajectories, train_config.batch_size) + + # 2. Configure Model + num_agents = trajectories.shape[-1] + model_config = ModelConfig( + ) + + model_config.num_agents=num_agents + model_config.input_dim=1 # Each agent has a single state value at time t + model_config.output_dim=1 + model_config.embedding_dim=32 + + # 3. Train the Model + # This relies on the modified train_model that returns final params + final_params, train_logs = train_model( + config=model_config, + inputs=inputs, + targets=targets, + true_graph=true_graph, + train_config=train_config + ) + + # 4. Evaluate + f1 = calculate_f1_score( + final_params, + model_config, + true_graph, + train_config.f1_threshold + ) + + loss_history_serializable = { + epoch: [loss.item() for loss in losses] + for epoch, losses in train_logs['loss_history'].items() + } + + random_id = str(uuid.uuid4()) + + # 5. Log Results + result_log = { + # "model_name": random_id, + "source_file": graph_file_name, + "graph_metrics": data['graph_metrics'], + "f1_score": f1, + "training_loss_history": loss_history_serializable, + "config": { + # Manually create the dictionary for the model config + "model": { + "num_agents": model_config.num_agents, + "input_dim": model_config.input_dim, + "output_dim": model_config.output_dim, + "embedding_dim": model_config.embedding_dim + }, + # This is correct because TrainConfig is a dataclass + "training": vars(train_config) + } + } + + result_final_params = final_params + + + all_results_for_agent.append(result_log) + + # 6. Save aggregated results for this agent count + results_dir = os.path.join(agent_dir_path, "results") + os.makedirs(results_dir, exist_ok=True) + + output_file = os.path.join(results_dir, "summary_results.json") + with open(output_file, 'w') as f: + json.dump(all_results_for_agent, f, indent=2) + + + model_path = os.path.join(results_dir, "model_params") + os.makedirs(model_path, exist_ok=True) + with open(os.path.join(model_path,"model_params" + ".pkl"), "wb") as f: + pickle.dump(final_params, f) + + print(f"āœ… Results for {agent_dir_name} saved to {output_file}") + + print("\nšŸŽ‰ Pipeline finished successfully!") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/train_and_eval_w_noise.py b/train_and_eval_w_noise.py new file mode 100644 index 0000000..faf804d --- /dev/null +++ b/train_and_eval_w_noise.py @@ -0,0 +1,217 @@ +import os +import json +import jax +import jax.numpy as jnp +import numpy as np +from dataclasses import dataclass, field, asdict +from enum import Enum +from tqdm import tqdm +from sklearn.metrics import f1_score + +# Import from your existing model file +from model import ModelConfig, train_model, get_attention_fn + +# --- MODIFICATION: Enums for clarity and safety --- +class DataSource(Enum): + CONSENSUS = "consensus" + KURAMOTO = "kuramoto" + +class NoiseType(Enum): + NONE = "none" + NORMAL = "normal" + UNIFORM = "uniform" + +# --- MODIFICATION: Updated TrainConfig --- +@dataclass +class TrainConfig: + """Configuration for the training process.""" + learning_rate: float = 1e-3 + epochs: int = 50 + batch_size: int = 64 + verbose: bool = False + log: bool = True + log_epoch_interval: int = 10 + + # Data and Noise parameters + data_source: DataSource = DataSource.CONSENSUS + noise_type: NoiseType = NoiseType.NORMAL + noise_level: float = 0.1 # Stddev for Normal, half-width for Uniform + + # Evaluation parameter + f1_threshold: float = 0.5 + + @property + def source_data_directory(self) -> str: + """The directory where the source dataset is located.""" + return f"{self.data_source.value}_dataset" + + @property + def results_directory_name(self) -> str: + """Generates a unique output directory name for separate logging.""" + if self.noise_type == NoiseType.NONE or self.noise_level == 0: + return f"results_noiseless" + return f"results_noise_{self.noise_type.value}_{self.noise_level}" + +# --- MODIFICATION: Updated data prep function to add noise --- +def prepare_data_for_model( + trajectories: np.ndarray, + key: jax.Array, + train_config: TrainConfig +) -> tuple[np.ndarray, np.ndarray]: + """ + Converts trajectories to input-output pairs and adds noise to the inputs. + """ + all_inputs, all_targets = [], [] + num_sims, num_timesteps, num_agents = trajectories.shape + + for sim_idx in range(num_sims): + all_inputs.append(trajectories[sim_idx, :-1, :]) + all_targets.append(trajectories[sim_idx, 1:, :]) + + full_dataset_inputs = np.concatenate(all_inputs, axis=0) + full_dataset_targets = np.concatenate(all_targets, axis=0) + + # --- NOISE INJECTION BLOCK --- + if train_config.noise_type != NoiseType.NONE and train_config.noise_level > 0: + noise_shape = full_dataset_inputs.shape + if train_config.noise_type == NoiseType.NORMAL: + noise = jax.random.normal(key, noise_shape) * train_config.noise_level + elif train_config.noise_type == NoiseType.UNIFORM: + noise = jax.random.uniform( + key, noise_shape, + minval=-train_config.noise_level, + maxval=train_config.noise_level + ) + full_dataset_inputs += np.array(noise) # Add noise to inputs + # --- END NOISE BLOCK --- + + full_dataset_inputs = np.expand_dims(full_dataset_inputs, axis=-1) + full_dataset_targets = np.expand_dims(full_dataset_targets, axis=-1) + + num_samples = full_dataset_inputs.shape[0] + num_batches = num_samples // train_config.batch_size + + truncated_inputs = full_dataset_inputs[:num_batches * train_config.batch_size] + truncated_targets = full_dataset_targets[:num_batches * train_config.batch_size] + + batched_inputs = truncated_inputs.reshape(num_batches, train_config.batch_size, num_agents, 1) + batched_targets = truncated_targets.reshape(num_batches, train_config.batch_size, num_agents, 1) + + return batched_inputs, batched_targets + +def calculate_f1_score( + params: dict, + model_config: ModelConfig, + true_graph: np.ndarray, + threshold: float +) -> float: + """Extracts the learned graph and computes the F1 score.""" + learned_scores = np.array(get_attention_fn(params, model_config)) + flat_scores = learned_scores.flatten() + min_s, max_s = flat_scores.min(), flat_scores.max() + if max_s > min_s: + learned_scores = (learned_scores - min_s) / (max_s - min_s) + predicted_graph = (learned_scores > threshold).astype(int) + + np.fill_diagonal(predicted_graph, 0) + np.fill_diagonal(true_graph, 0) + + return f1_score(true_graph.flatten(), predicted_graph.flatten()) + +def main(): + """Main script to run the training and evaluation pipeline.""" + + # Configure your training run here + train_config = TrainConfig( + noise_type=NoiseType.NORMAL, + noise_level=0.1 + ) + + if not os.path.isdir(train_config.source_data_directory): + print(f"Error: Source data '{train_config.source_data_directory}' not found.") + return + + print(f"šŸš€ Starting training pipeline for '{train_config.data_source.value}' data.") + print(f"Noise Configuration: type={train_config.noise_type.value}, level={train_config.noise_level}") + + # --- MODIFICATION: Main JAX key for noise generation --- + main_key = jax.random.PRNGKey(42) + + agent_dirs = sorted( + [d for d in os.listdir(train_config.source_data_directory) if d.startswith("agents_")], + key=lambda x: int(x.split('_')[1]) + ) + + for agent_dir_name in agent_dirs: + agent_dir_path = os.path.join(train_config.source_data_directory, agent_dir_name) + all_results_for_agent = [] + graph_files = sorted([f for f in os.listdir(agent_dir_path) if f.endswith(".json")]) + + print(f"\nProcessing {len(graph_files)} graphs for {agent_dir_name}...") + + for graph_file_name in tqdm(graph_files, desc=f"Training on {agent_dir_name}"): + file_path = os.path.join(agent_dir_path, graph_file_name) + + with open(file_path, 'r') as f: + data = json.load(f) + + main_key, data_key = jax.random.split(main_key) + trajectories = np.array(data['trajectories']) + true_graph = np.array(data['adjacency_matrix']) + + # --- MODIFICATION: Pass key and config to data prep --- + inputs, targets = prepare_data_for_model(trajectories, data_key, train_config) + + num_agents = int(trajectories.shape[-1]) + model_config = ModelConfig() + model_config.num_agents = num_agents + model_config.input_dim = 1 + model_config.output_dim = 1 + model_config.embedding_dim = 32 + + final_params, train_logs = train_model( + config=model_config, + inputs=inputs, + targets=targets, + true_graph=true_graph, + train_config=train_config + ) + + f1 = calculate_f1_score(final_params, model_config, true_graph, train_config.f1_threshold) + + loss_history_serializable = { + epoch: [loss.item() for loss in losses] + for epoch, losses in train_logs['loss_history'].items() + } + + result_log = { + "source_file": graph_file_name, + "graph_metrics": data['graph_metrics'], + "f1_score": f1, + "training_loss_history": loss_history_serializable, + "config": { + "model": { + "num_agents": model_config.num_agents, + "input_dim": model_config.input_dim, + "output_dim": model_config.output_dim, + "embedding_dim": model_config.embedding_dim + }, + "training": asdict(train_config) + } + } + all_results_for_agent.append(result_log) + + # --- MODIFICATION: Save to a separate results directory --- + results_dir = os.path.join(agent_dir_path, train_config.results_directory_name) + os.makedirs(results_dir, exist_ok=True) + + output_file = os.path.join(results_dir, "summary_results.json") + with open(output_file, 'w') as f: + json.dump(all_results_for_agent, f, indent=2) + + print(f"āœ… Results for {agent_dir_name} saved to {output_file}") + + print("\nšŸŽ‰ Pipeline finished successfully!") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/uv.lock b/uv.lock index 41ce0fe..5987ef0 100644 --- a/uv.lock +++ b/uv.lock @@ -6,6 +6,15 @@ resolution-markers = [ "python_full_version < '3.13'", ] +[[package]] +name = "absl-py" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/2a/c93173ffa1b39c1d0395b7e842bbdc62e556ca9d8d3b5572926f3e4ca752/absl_py-2.3.1.tar.gz", hash = "sha256:a97820526f7fbfd2ec1bce83f3f25e3a14840dac0d8e02a0b71cd75db3f77fc9", size = 116588, upload-time = "2025-07-03T09:31:44.05Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/aa/ba0014cc4659328dc818a28827be78e6d97312ab0cb98105a770924dc11e/absl_py-2.3.1-py3-none-any.whl", hash = "sha256:eeecf07f0c2a93ace0772c92e596ace6d3d3996c042b2128459aaae2a76de11d", size = 135811, upload-time = "2025-07-03T09:31:42.253Z" }, +] + [[package]] name = "anyio" version = "4.9.0" @@ -218,6 +227,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" }, ] +[[package]] +name = "chex" +version = "0.1.90" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, + { name = "setuptools" }, + { name = "toolz" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/70/53c7d404ce9e2a94009aea7f77ef6e392f6740e071c62683a506647c520f/chex-0.1.90.tar.gz", hash = "sha256:d3c375aeb6154b08f1cccd2bee4ed83659ee2198a6acf1160d2fe2e4a6c87b5c", size = 92363, upload-time = "2025-07-23T19:50:47.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/3d/46bb04776c465cea2dd8aa2d4b61ab610b707f798f47838ef7e6105b025c/chex-0.1.90-py3-none-any.whl", hash = "sha256:fce3de82588f72d4796e545e574a433aa29229cbdcf792555e41bead24b704ae", size = 101047, upload-time = "2025-07-23T19:50:46.603Z" }, +] + [[package]] name = "colorama" version = "0.4.6" @@ -386,6 +413,9 @@ dependencies = [ { name = "jax", extra = ["cuda12"] }, { name = "jupyter" }, { name = "matplotlib" }, + { name = "networkx" }, + { name = "optax" }, + { name = "scikit-learn" }, { name = "seaborn" }, { name = "tqdm" }, ] @@ -397,6 +427,9 @@ requires-dist = [ { name = "jax", extras = ["cuda12"], specifier = ">=0.7.0" }, { name = "jupyter", specifier = ">=1.1.1" }, { name = "matplotlib", specifier = ">=3.10.3" }, + { name = "networkx", specifier = ">=3.5" }, + { name = "optax", specifier = ">=0.2.5" }, + { name = "scikit-learn", specifier = ">=1.7.1" }, { name = "seaborn", specifier = ">=0.13.2" }, { name = "tqdm", specifier = ">=4.67.1" }, ] @@ -641,6 +674,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "joblib" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/fe/0f5a938c54105553436dbff7a61dc4fed4b1b2c98852f8833beaf4d5968f/joblib-1.5.1.tar.gz", hash = "sha256:f4f86e351f39fe3d0d32a9f2c3d8af1ee4cec285aafcb27003dda5205576b444", size = 330475, upload-time = "2025-05-23T12:04:37.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/4f/1195bbac8e0c2acc5f740661631d8d750dc38d4a32b23ee5df3cde6f4e0d/joblib-1.5.1-py3-none-any.whl", hash = "sha256:4719a31f054c7d766948dcd83e9613686b27114f190f717cec7eaa2084f8a74a", size = 307746, upload-time = "2025-05-23T12:04:35.124Z" }, +] + [[package]] name = "json5" version = "0.12.0" @@ -1141,6 +1183,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, ] +[[package]] +name = "networkx" +version = "3.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" }, +] + [[package]] name = "notebook" version = "7.4.4" @@ -1373,6 +1424,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" }, ] +[[package]] +name = "optax" +version = "0.2.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "chex" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/75/1e011953c48be502d4d84fa8458e91be7c6f983002511669bddd7b1a065f/optax-0.2.5.tar.gz", hash = "sha256:b2e38c7aea376186deae758ba7a258e6ef760c6f6131e9e11bc561c65386d594", size = 258548, upload-time = "2025-06-10T17:00:47.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/33/f86091c706db1a5459f501830241afff2ecab3532725c188ea57be6e54de/optax-0.2.5-py3-none-any.whl", hash = "sha256:966deae936207f268ac8f564d8ed228d645ac1aaddefbbf194096d2299b24ba8", size = 354324, upload-time = "2025-06-10T17:00:46.062Z" }, +] + [[package]] name = "overrides" version = "7.7.0" @@ -1862,6 +1929,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/75/04/5302cea1aa26d886d34cadbf2dc77d90d7737e576c0065f357b96dc7a1a6/rpds_py-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f14440b9573a6f76b4ee4770c13f0b5921f71dde3b6fcb8dabbefd13b7fe05d7", size = 232821, upload-time = "2025-07-01T15:55:55.167Z" }, ] +[[package]] +name = "scikit-learn" +version = "1.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/41/84/5f4af978fff619706b8961accac84780a6d298d82a8873446f72edb4ead0/scikit_learn-1.7.1.tar.gz", hash = "sha256:24b3f1e976a4665aa74ee0fcaac2b8fccc6ae77c8e07ab25da3ba6d3292b9802", size = 7190445, upload-time = "2025-07-18T08:01:54.5Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/16/57f176585b35ed865f51b04117947fe20f130f78940c6477b6d66279c9c2/scikit_learn-1.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3cee419b49b5bbae8796ecd690f97aa412ef1674410c23fc3257c6b8b85b8087", size = 9260431, upload-time = "2025-07-18T08:01:22.77Z" }, + { url = "https://files.pythonhosted.org/packages/67/4e/899317092f5efcab0e9bc929e3391341cec8fb0e816c4789686770024580/scikit_learn-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2fd8b8d35817b0d9ebf0b576f7d5ffbbabdb55536b0655a8aaae629d7ffd2e1f", size = 8637191, upload-time = "2025-07-18T08:01:24.731Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1b/998312db6d361ded1dd56b457ada371a8d8d77ca2195a7d18fd8a1736f21/scikit_learn-1.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:588410fa19a96a69763202f1d6b7b91d5d7a5d73be36e189bc6396bfb355bd87", size = 9486346, upload-time = "2025-07-18T08:01:26.713Z" }, + { url = "https://files.pythonhosted.org/packages/ad/09/a2aa0b4e644e5c4ede7006748f24e72863ba2ae71897fecfd832afea01b4/scikit_learn-1.7.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3142f0abe1ad1d1c31a2ae987621e41f6b578144a911ff4ac94781a583adad7", size = 9290988, upload-time = "2025-07-18T08:01:28.938Z" }, + { url = "https://files.pythonhosted.org/packages/15/fa/c61a787e35f05f17fc10523f567677ec4eeee5f95aa4798dbbbcd9625617/scikit_learn-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3ddd9092c1bd469acab337d87930067c87eac6bd544f8d5027430983f1e1ae88", size = 8735568, upload-time = "2025-07-18T08:01:30.936Z" }, + { url = "https://files.pythonhosted.org/packages/52/f8/e0533303f318a0f37b88300d21f79b6ac067188d4824f1047a37214ab718/scikit_learn-1.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b7839687fa46d02e01035ad775982f2470be2668e13ddd151f0f55a5bf123bae", size = 9213143, upload-time = "2025-07-18T08:01:32.942Z" }, + { url = "https://files.pythonhosted.org/packages/71/f3/f1df377d1bdfc3e3e2adc9c119c238b182293e6740df4cbeac6de2cc3e23/scikit_learn-1.7.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a10f276639195a96c86aa572ee0698ad64ee939a7b042060b98bd1930c261d10", size = 8591977, upload-time = "2025-07-18T08:01:34.967Z" }, + { url = "https://files.pythonhosted.org/packages/99/72/c86a4cd867816350fe8dee13f30222340b9cd6b96173955819a5561810c5/scikit_learn-1.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:13679981fdaebc10cc4c13c43344416a86fcbc61449cb3e6517e1df9d12c8309", size = 9436142, upload-time = "2025-07-18T08:01:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/e8/66/277967b29bd297538dc7a6ecfb1a7dce751beabd0d7f7a2233be7a4f7832/scikit_learn-1.7.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f1262883c6a63f067a980a8cdd2d2e7f2513dddcef6a9eaada6416a7a7cbe43", size = 9282996, upload-time = "2025-07-18T08:01:39.721Z" }, + { url = "https://files.pythonhosted.org/packages/e2/47/9291cfa1db1dae9880420d1e07dbc7e8dd4a7cdbc42eaba22512e6bde958/scikit_learn-1.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:ca6d31fb10e04d50bfd2b50d66744729dbb512d4efd0223b864e2fdbfc4cee11", size = 8707418, upload-time = "2025-07-18T08:01:42.124Z" }, + { url = "https://files.pythonhosted.org/packages/61/95/45726819beccdaa34d3362ea9b2ff9f2b5d3b8bf721bd632675870308ceb/scikit_learn-1.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:781674d096303cfe3d351ae6963ff7c958db61cde3421cd490e3a5a58f2a94ae", size = 9561466, upload-time = "2025-07-18T08:01:44.195Z" }, + { url = "https://files.pythonhosted.org/packages/ee/1c/6f4b3344805de783d20a51eb24d4c9ad4b11a7f75c1801e6ec6d777361fd/scikit_learn-1.7.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:10679f7f125fe7ecd5fad37dd1aa2daae7e3ad8df7f3eefa08901b8254b3e12c", size = 9040467, upload-time = "2025-07-18T08:01:46.671Z" }, + { url = "https://files.pythonhosted.org/packages/6f/80/abe18fe471af9f1d181904203d62697998b27d9b62124cd281d740ded2f9/scikit_learn-1.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1f812729e38c8cb37f760dce71a9b83ccfb04f59b3dca7c6079dcdc60544fa9e", size = 9532052, upload-time = "2025-07-18T08:01:48.676Z" }, + { url = "https://files.pythonhosted.org/packages/14/82/b21aa1e0c4cee7e74864d3a5a721ab8fcae5ca55033cb6263dca297ed35b/scikit_learn-1.7.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88e1a20131cf741b84b89567e1717f27a2ced228e0f29103426102bc2e3b8ef7", size = 9361575, upload-time = "2025-07-18T08:01:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/f4777fcd5627dc6695fa6b92179d0edb7a3ac1b91bcd9a1c7f64fa7ade23/scikit_learn-1.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b1bd1d919210b6a10b7554b717c9000b5485aa95a1d0f177ae0d7ee8ec750da5", size = 9277310, upload-time = "2025-07-18T08:01:52.547Z" }, +] + [[package]] name = "scipy" version = "1.16.0" @@ -1987,6 +2083,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, ] +[[package]] +name = "threadpoolctl" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, +] + [[package]] name = "tinycss2" version = "1.4.0" @@ -1999,6 +2104,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, ] +[[package]] +name = "toolz" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/0b/d80dfa675bf592f636d1ea0b835eab4ec8df6e9415d8cfd766df54456123/toolz-1.0.0.tar.gz", hash = "sha256:2c86e3d9a04798ac556793bced838816296a2f085017664e4995cb40a1047a02", size = 66790, upload-time = "2024-10-04T16:17:04.001Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/98/eb27cc78ad3af8e302c9d8ff4977f5026676e130d28dd7578132a457170c/toolz-1.0.0-py3-none-any.whl", hash = "sha256:292c8f1c4e7516bf9086f8850935c799a874039c8bcf959d47b600e4c44a6236", size = 56383, upload-time = "2024-10-04T16:17:01.533Z" }, +] + [[package]] name = "tornado" version = "6.5.1"